annotate src/cpu/x86/vm/c1_Runtime1_x86.cpp @ 6674:fd71ca8c5f88

VM infrstructure for OnStackReplacement
author Lukas Stadler <lukas.stadler@jku.at>
date Wed, 07 Nov 2012 13:18:04 +0100
parents 2a0c9f20baa1
children e522a00b91aa
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1 /*
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
2 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load
duke
parents:
diff changeset
4 *
a61af66fc99e Initial load
duke
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load
duke
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load
duke
parents:
diff changeset
7 * published by the Free Software Foundation.
a61af66fc99e Initial load
duke
parents:
diff changeset
8 *
a61af66fc99e Initial load
duke
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load
duke
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load
duke
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load
duke
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load
duke
parents:
diff changeset
13 * accompanied this code).
a61af66fc99e Initial load
duke
parents:
diff changeset
14 *
a61af66fc99e Initial load
duke
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load
duke
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load
duke
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load
duke
parents:
diff changeset
18 *
1552
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1368
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1368
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1368
diff changeset
21 * questions.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
22 *
a61af66fc99e Initial load
duke
parents:
diff changeset
23 */
a61af66fc99e Initial load
duke
parents:
diff changeset
24
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
25 #include "precompiled.hpp"
2415
09f96c3ff1ad 7032388: guarantee(VM_Version::supports_cmov()) failed: illegal instruction on i586 after 6919934
twisti
parents: 2321
diff changeset
26 #include "asm/assembler.hpp"
1972
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
27 #include "c1/c1_Defs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
28 #include "c1/c1_MacroAssembler.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
29 #include "c1/c1_Runtime1.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
30 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
31 #include "nativeInst_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
32 #include "oops/compiledICHolderOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
33 #include "oops/oop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
34 #include "prims/jvmtiExport.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
35 #include "register_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
36 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
37 #include "runtime/signature.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
38 #include "runtime/vframeArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot
stefank
parents: 1783
diff changeset
39 #include "vmreg_x86.inline.hpp"
0
a61af66fc99e Initial load
duke
parents:
diff changeset
40
2662
440ceca8e3d7 Add exception handlers only to Invoke and Throw instructions. Deoptimize if there is an exception in a HotSpot runtime call.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2608
diff changeset
41 static void restore_live_registers(StubAssembler* sasm, bool restore_fpu_registers = true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
42
a61af66fc99e Initial load
duke
parents:
diff changeset
43 // Implementation of StubAssembler
a61af66fc99e Initial load
duke
parents:
diff changeset
44
a61af66fc99e Initial load
duke
parents:
diff changeset
45 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, int args_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
46 // setup registers
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
47 const Register thread = NOT_LP64(rdi) LP64_ONLY(r15_thread); // is callee-saved register (Visual C++ calling conventions)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
48 assert(!(oop_result1->is_valid() || oop_result2->is_valid()) || oop_result1 != oop_result2, "registers must be different");
a61af66fc99e Initial load
duke
parents:
diff changeset
49 assert(oop_result1 != thread && oop_result2 != thread, "registers must be different");
a61af66fc99e Initial load
duke
parents:
diff changeset
50 assert(args_size >= 0, "illegal args_size");
5904
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
51 bool align_stack = false;
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
52 #ifdef _LP64
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
53 // At a method handle call, the stack may not be properly aligned
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
54 // when returning with an exception.
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
55 align_stack = (stub_id() == Runtime1::handle_exception_from_callee_id);
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
56 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
57
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
58 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
59 mov(c_rarg0, thread);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
60 set_num_rt_args(0); // Nothing on stack
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
61 #else
0
a61af66fc99e Initial load
duke
parents:
diff changeset
62 set_num_rt_args(1 + args_size);
a61af66fc99e Initial load
duke
parents:
diff changeset
63
a61af66fc99e Initial load
duke
parents:
diff changeset
64 // push java thread (becomes first argument of C function)
a61af66fc99e Initial load
duke
parents:
diff changeset
65 get_thread(thread);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
66 push(thread);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
67 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
68
5904
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
69 int call_offset;
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
70 if (!align_stack) {
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
71 set_last_Java_frame(thread, noreg, rbp, NULL);
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
72 } else {
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
73 address the_pc = pc();
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
74 call_offset = offset();
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
75 set_last_Java_frame(thread, noreg, rbp, the_pc);
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
76 andptr(rsp, -(StackAlignmentInBytes)); // Align stack
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
77 }
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
78
0
a61af66fc99e Initial load
duke
parents:
diff changeset
79 // do the call
a61af66fc99e Initial load
duke
parents:
diff changeset
80 call(RuntimeAddress(entry));
5904
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
81 if (!align_stack) {
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
82 call_offset = offset();
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
83 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
84 // verify callee-saved register
a61af66fc99e Initial load
duke
parents:
diff changeset
85 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
86 guarantee(thread != rax, "change this code");
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
87 push(rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
88 { Label L;
a61af66fc99e Initial load
duke
parents:
diff changeset
89 get_thread(rax);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
90 cmpptr(thread, rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
91 jcc(Assembler::equal, L);
a61af66fc99e Initial load
duke
parents:
diff changeset
92 int3();
a61af66fc99e Initial load
duke
parents:
diff changeset
93 stop("StubAssembler::call_RT: rdi not callee saved?");
a61af66fc99e Initial load
duke
parents:
diff changeset
94 bind(L);
a61af66fc99e Initial load
duke
parents:
diff changeset
95 }
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
96 pop(rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
97 #endif
5904
bf7796b7367a 7148486: At a method handle call returning with an exception may call the runtime with misaligned stack (x64)
roland
parents: 4771
diff changeset
98 reset_last_Java_frame(thread, true, align_stack);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
99
a61af66fc99e Initial load
duke
parents:
diff changeset
100 // discard thread and arguments
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
101 NOT_LP64(addptr(rsp, num_rt_args()*BytesPerWord));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
102
a61af66fc99e Initial load
duke
parents:
diff changeset
103 // check for pending exceptions
a61af66fc99e Initial load
duke
parents:
diff changeset
104 { Label L;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
105 cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
106 jcc(Assembler::equal, L);
a61af66fc99e Initial load
duke
parents:
diff changeset
107 // exception pending => remove activation and forward to exception handler
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
108 movptr(rax, Address(thread, Thread::pending_exception_offset()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
109 // make sure that the vm_results are cleared
a61af66fc99e Initial load
duke
parents:
diff changeset
110 if (oop_result1->is_valid()) {
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 380
diff changeset
111 movptr(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
112 }
a61af66fc99e Initial load
duke
parents:
diff changeset
113 if (oop_result2->is_valid()) {
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 380
diff changeset
114 movptr(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
115 }
5124
837a304d0ca8 C1 bugfix, fixed C1 compilation errors
Christian Haeubl <christian.haeubl@oracle.com>
parents: 5111
diff changeset
116 #ifdef GRAAL
5056
2f2c6347fce4 comments cleanup/retagging
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4977
diff changeset
117 // (thomaswue) Deoptimize in case of an exception.
2662
440ceca8e3d7 Add exception handlers only to Invoke and Throw instructions. Deoptimize if there is an exception in a HotSpot runtime call.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2608
diff changeset
118 restore_live_registers(this, false);
440ceca8e3d7 Add exception handlers only to Invoke and Throw instructions. Deoptimize if there is an exception in a HotSpot runtime call.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2608
diff changeset
119 movptr(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
440ceca8e3d7 Add exception handlers only to Invoke and Throw instructions. Deoptimize if there is an exception in a HotSpot runtime call.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2608
diff changeset
120 leave();
5111
422c979ff392 fixed two cases where DeoptAction was invalid
Christian Haeubl <christian.haeubl@oracle.com>
parents: 5056
diff changeset
121 movl(rscratch1, Deoptimization::make_trap_request(Deoptimization::Reason_constraint, Deoptimization::Action_reinterpret));
2662
440ceca8e3d7 Add exception handlers only to Invoke and Throw instructions. Deoptimize if there is an exception in a HotSpot runtime call.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2608
diff changeset
122 jump(RuntimeAddress(SharedRuntime::deopt_blob()->uncommon_trap()));
5124
837a304d0ca8 C1 bugfix, fixed C1 compilation errors
Christian Haeubl <christian.haeubl@oracle.com>
parents: 5111
diff changeset
123 #else
0
a61af66fc99e Initial load
duke
parents:
diff changeset
124 if (frame_size() == no_frame_size) {
a61af66fc99e Initial load
duke
parents:
diff changeset
125 leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
126 jump(RuntimeAddress(StubRoutines::forward_exception_entry()));
a61af66fc99e Initial load
duke
parents:
diff changeset
127 } else if (_stub_id == Runtime1::forward_exception_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
128 should_not_reach_here();
a61af66fc99e Initial load
duke
parents:
diff changeset
129 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
130 jump(RuntimeAddress(Runtime1::entry_for(Runtime1::forward_exception_id)));
a61af66fc99e Initial load
duke
parents:
diff changeset
131 }
5124
837a304d0ca8 C1 bugfix, fixed C1 compilation errors
Christian Haeubl <christian.haeubl@oracle.com>
parents: 5111
diff changeset
132 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
133 bind(L);
a61af66fc99e Initial load
duke
parents:
diff changeset
134 }
a61af66fc99e Initial load
duke
parents:
diff changeset
135 // get oop results if there are any and reset the values in the thread
a61af66fc99e Initial load
duke
parents:
diff changeset
136 if (oop_result1->is_valid()) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
137 movptr(oop_result1, Address(thread, JavaThread::vm_result_offset()));
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 380
diff changeset
138 movptr(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
139 verify_oop(oop_result1);
a61af66fc99e Initial load
duke
parents:
diff changeset
140 }
a61af66fc99e Initial load
duke
parents:
diff changeset
141 if (oop_result2->is_valid()) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
142 movptr(oop_result2, Address(thread, JavaThread::vm_result_2_offset()));
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 380
diff changeset
143 movptr(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
144 verify_oop(oop_result2);
a61af66fc99e Initial load
duke
parents:
diff changeset
145 }
a61af66fc99e Initial load
duke
parents:
diff changeset
146 return call_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
147 }
a61af66fc99e Initial load
duke
parents:
diff changeset
148
a61af66fc99e Initial load
duke
parents:
diff changeset
149
a61af66fc99e Initial load
duke
parents:
diff changeset
150 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
151 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
152 mov(c_rarg1, arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
153 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
154 push(arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
155 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
156 return call_RT(oop_result1, oop_result2, entry, 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
157 }
a61af66fc99e Initial load
duke
parents:
diff changeset
158
a61af66fc99e Initial load
duke
parents:
diff changeset
159
a61af66fc99e Initial load
duke
parents:
diff changeset
160 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
161 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
162 if (c_rarg1 == arg2) {
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
163 if (c_rarg2 == arg1) {
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
164 xchgq(arg1, arg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
165 } else {
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
166 mov(c_rarg2, arg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
167 mov(c_rarg1, arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
168 }
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
169 } else {
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
170 mov(c_rarg1, arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
171 mov(c_rarg2, arg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
172 }
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
173 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
174 push(arg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
175 push(arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
176 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
177 return call_RT(oop_result1, oop_result2, entry, 2);
a61af66fc99e Initial load
duke
parents:
diff changeset
178 }
a61af66fc99e Initial load
duke
parents:
diff changeset
179
a61af66fc99e Initial load
duke
parents:
diff changeset
180
a61af66fc99e Initial load
duke
parents:
diff changeset
181 int StubAssembler::call_RT(Register oop_result1, Register oop_result2, address entry, Register arg1, Register arg2, Register arg3) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
182 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
183 // if there is any conflict use the stack
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
184 if (arg1 == c_rarg2 || arg1 == c_rarg3 ||
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
185 arg2 == c_rarg1 || arg1 == c_rarg3 ||
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
186 arg3 == c_rarg1 || arg1 == c_rarg2) {
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
187 push(arg3);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
188 push(arg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
189 push(arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
190 pop(c_rarg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
191 pop(c_rarg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
192 pop(c_rarg3);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
193 } else {
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
194 mov(c_rarg1, arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
195 mov(c_rarg2, arg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
196 mov(c_rarg3, arg3);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
197 }
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
198 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
199 push(arg3);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
200 push(arg2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
201 push(arg1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
202 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
203 return call_RT(oop_result1, oop_result2, entry, 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
204 }
a61af66fc99e Initial load
duke
parents:
diff changeset
205
a61af66fc99e Initial load
duke
parents:
diff changeset
206
a61af66fc99e Initial load
duke
parents:
diff changeset
207 // Implementation of StubFrame
a61af66fc99e Initial load
duke
parents:
diff changeset
208
a61af66fc99e Initial load
duke
parents:
diff changeset
209 class StubFrame: public StackObj {
a61af66fc99e Initial load
duke
parents:
diff changeset
210 private:
a61af66fc99e Initial load
duke
parents:
diff changeset
211 StubAssembler* _sasm;
a61af66fc99e Initial load
duke
parents:
diff changeset
212
a61af66fc99e Initial load
duke
parents:
diff changeset
213 public:
a61af66fc99e Initial load
duke
parents:
diff changeset
214 StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
215 void load_argument(int offset_in_words, Register reg);
a61af66fc99e Initial load
duke
parents:
diff changeset
216
a61af66fc99e Initial load
duke
parents:
diff changeset
217 ~StubFrame();
a61af66fc99e Initial load
duke
parents:
diff changeset
218 };
a61af66fc99e Initial load
duke
parents:
diff changeset
219
a61af66fc99e Initial load
duke
parents:
diff changeset
220
a61af66fc99e Initial load
duke
parents:
diff changeset
221 #define __ _sasm->
a61af66fc99e Initial load
duke
parents:
diff changeset
222
a61af66fc99e Initial load
duke
parents:
diff changeset
223 StubFrame::StubFrame(StubAssembler* sasm, const char* name, bool must_gc_arguments) {
a61af66fc99e Initial load
duke
parents:
diff changeset
224 _sasm = sasm;
a61af66fc99e Initial load
duke
parents:
diff changeset
225 __ set_info(name, must_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
226 __ enter();
a61af66fc99e Initial load
duke
parents:
diff changeset
227 }
a61af66fc99e Initial load
duke
parents:
diff changeset
228
a61af66fc99e Initial load
duke
parents:
diff changeset
229 // load parameters that were stored with LIR_Assembler::store_parameter
a61af66fc99e Initial load
duke
parents:
diff changeset
230 // Note: offsets for store_parameter and load_argument must match
a61af66fc99e Initial load
duke
parents:
diff changeset
231 void StubFrame::load_argument(int offset_in_words, Register reg) {
a61af66fc99e Initial load
duke
parents:
diff changeset
232 // rbp, + 0: link
a61af66fc99e Initial load
duke
parents:
diff changeset
233 // + 1: return address
a61af66fc99e Initial load
duke
parents:
diff changeset
234 // + 2: argument with offset 0
a61af66fc99e Initial load
duke
parents:
diff changeset
235 // + 3: argument with offset 1
a61af66fc99e Initial load
duke
parents:
diff changeset
236 // + 4: ...
a61af66fc99e Initial load
duke
parents:
diff changeset
237
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
238 __ movptr(reg, Address(rbp, (offset_in_words + 2) * BytesPerWord));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
239 }
a61af66fc99e Initial load
duke
parents:
diff changeset
240
a61af66fc99e Initial load
duke
parents:
diff changeset
241
a61af66fc99e Initial load
duke
parents:
diff changeset
242 StubFrame::~StubFrame() {
a61af66fc99e Initial load
duke
parents:
diff changeset
243 __ leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
244 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
245 }
a61af66fc99e Initial load
duke
parents:
diff changeset
246
a61af66fc99e Initial load
duke
parents:
diff changeset
247 #undef __
a61af66fc99e Initial load
duke
parents:
diff changeset
248
a61af66fc99e Initial load
duke
parents:
diff changeset
249
a61af66fc99e Initial load
duke
parents:
diff changeset
250 // Implementation of Runtime1
a61af66fc99e Initial load
duke
parents:
diff changeset
251
a61af66fc99e Initial load
duke
parents:
diff changeset
252 #define __ sasm->
a61af66fc99e Initial load
duke
parents:
diff changeset
253
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
254 const int float_regs_as_doubles_size_in_slots = pd_nof_fpu_regs_frame_map * 2;
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
255 const int xmm_regs_as_doubles_size_in_slots = FrameMap::nof_xmm_regs * 2;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
256
a61af66fc99e Initial load
duke
parents:
diff changeset
257 // Stack layout for saving/restoring all the registers needed during a runtime
a61af66fc99e Initial load
duke
parents:
diff changeset
258 // call (this includes deoptimization)
a61af66fc99e Initial load
duke
parents:
diff changeset
259 // Note: note that users of this frame may well have arguments to some runtime
a61af66fc99e Initial load
duke
parents:
diff changeset
260 // while these values are on the stack. These positions neglect those arguments
a61af66fc99e Initial load
duke
parents:
diff changeset
261 // but the code in save_live_registers will take the argument count into
a61af66fc99e Initial load
duke
parents:
diff changeset
262 // account.
a61af66fc99e Initial load
duke
parents:
diff changeset
263 //
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
264 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
265 #define SLOT2(x) x,
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
266 #define SLOT_PER_WORD 2
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
267 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
268 #define SLOT2(x)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
269 #define SLOT_PER_WORD 1
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
270 #endif // _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
271
0
a61af66fc99e Initial load
duke
parents:
diff changeset
272 enum reg_save_layout {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
273 // 64bit needs to keep stack 16 byte aligned. So we add some alignment dummies to make that
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
274 // happen and will assert if the stack size we create is misaligned
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
275 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
276 align_dummy_0, align_dummy_1,
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
277 #endif // _LP64
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
278 #ifdef _WIN64
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
279 // Windows always allocates space for it's argument registers (see
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
280 // frame::arg_reg_save_area_bytes).
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
281 arg_reg_save_1, arg_reg_save_1H, // 0, 4
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
282 arg_reg_save_2, arg_reg_save_2H, // 8, 12
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
283 arg_reg_save_3, arg_reg_save_3H, // 16, 20
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
284 arg_reg_save_4, arg_reg_save_4H, // 24, 28
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
285 #endif // _WIN64
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
286 xmm_regs_as_doubles_off, // 32
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
287 float_regs_as_doubles_off = xmm_regs_as_doubles_off + xmm_regs_as_doubles_size_in_slots, // 160
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
288 fpu_state_off = float_regs_as_doubles_off + float_regs_as_doubles_size_in_slots, // 224
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
289 // fpu_state_end_off is exclusive
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
290 fpu_state_end_off = fpu_state_off + (FPUStateSizeInWords / SLOT_PER_WORD), // 352
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
291 marker = fpu_state_end_off, SLOT2(markerH) // 352, 356
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
292 extra_space_offset, // 360
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
293 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
294 r15_off = extra_space_offset, r15H_off, // 360, 364
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
295 r14_off, r14H_off, // 368, 372
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
296 r13_off, r13H_off, // 376, 380
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
297 r12_off, r12H_off, // 384, 388
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
298 r11_off, r11H_off, // 392, 396
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
299 r10_off, r10H_off, // 400, 404
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
300 r9_off, r9H_off, // 408, 412
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
301 r8_off, r8H_off, // 416, 420
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
302 rdi_off, rdiH_off, // 424, 428
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
303 #else
0
a61af66fc99e Initial load
duke
parents:
diff changeset
304 rdi_off = extra_space_offset,
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
305 #endif // _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
306 rsi_off, SLOT2(rsiH_off) // 432, 436
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
307 rbp_off, SLOT2(rbpH_off) // 440, 444
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
308 rsp_off, SLOT2(rspH_off) // 448, 452
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
309 rbx_off, SLOT2(rbxH_off) // 456, 460
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
310 rdx_off, SLOT2(rdxH_off) // 464, 468
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
311 rcx_off, SLOT2(rcxH_off) // 472, 476
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
312 rax_off, SLOT2(raxH_off) // 480, 484
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
313 saved_rbp_off, SLOT2(saved_rbpH_off) // 488, 492
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
314 return_off, SLOT2(returnH_off) // 496, 500
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
315 reg_save_frame_size // As noted: neglects any parameters to runtime // 504
0
a61af66fc99e Initial load
duke
parents:
diff changeset
316 };
a61af66fc99e Initial load
duke
parents:
diff changeset
317
a61af66fc99e Initial load
duke
parents:
diff changeset
318
a61af66fc99e Initial load
duke
parents:
diff changeset
319
a61af66fc99e Initial load
duke
parents:
diff changeset
320 // Save off registers which might be killed by calls into the runtime.
a61af66fc99e Initial load
duke
parents:
diff changeset
321 // Tries to smart of about FP registers. In particular we separate
a61af66fc99e Initial load
duke
parents:
diff changeset
322 // saving and describing the FPU registers for deoptimization since we
a61af66fc99e Initial load
duke
parents:
diff changeset
323 // have to save the FPU registers twice if we describe them and on P4
a61af66fc99e Initial load
duke
parents:
diff changeset
324 // saving FPU registers which don't contain anything appears
a61af66fc99e Initial load
duke
parents:
diff changeset
325 // expensive. The deopt blob is the only thing which needs to
a61af66fc99e Initial load
duke
parents:
diff changeset
326 // describe FPU registers. In all other cases it should be sufficient
a61af66fc99e Initial load
duke
parents:
diff changeset
327 // to simply save their current value.
a61af66fc99e Initial load
duke
parents:
diff changeset
328
a61af66fc99e Initial load
duke
parents:
diff changeset
329 static OopMap* generate_oop_map(StubAssembler* sasm, int num_rt_args,
a61af66fc99e Initial load
duke
parents:
diff changeset
330 bool save_fpu_registers = true) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
331
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
332 // In 64bit all the args are in regs so there are no additional stack slots
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
333 LP64_ONLY(num_rt_args = 0);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
334 LP64_ONLY(assert((reg_save_frame_size * VMRegImpl::stack_slot_size) % 16 == 0, "must be 16 byte aligned");)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
335 int frame_size_in_slots = reg_save_frame_size + num_rt_args; // args + thread
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
336 sasm->set_frame_size(frame_size_in_slots / VMRegImpl::slots_per_word );
0
a61af66fc99e Initial load
duke
parents:
diff changeset
337
a61af66fc99e Initial load
duke
parents:
diff changeset
338 // record saved value locations in an OopMap
a61af66fc99e Initial load
duke
parents:
diff changeset
339 // locations are offsets from sp after runtime call; num_rt_args is number of arguments in call, including thread
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
340 OopMap* map = new OopMap(frame_size_in_slots, 0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
341 map->set_callee_saved(VMRegImpl::stack2reg(rax_off + num_rt_args), rax->as_VMReg());
a61af66fc99e Initial load
duke
parents:
diff changeset
342 map->set_callee_saved(VMRegImpl::stack2reg(rcx_off + num_rt_args), rcx->as_VMReg());
a61af66fc99e Initial load
duke
parents:
diff changeset
343 map->set_callee_saved(VMRegImpl::stack2reg(rdx_off + num_rt_args), rdx->as_VMReg());
a61af66fc99e Initial load
duke
parents:
diff changeset
344 map->set_callee_saved(VMRegImpl::stack2reg(rbx_off + num_rt_args), rbx->as_VMReg());
a61af66fc99e Initial load
duke
parents:
diff changeset
345 map->set_callee_saved(VMRegImpl::stack2reg(rsi_off + num_rt_args), rsi->as_VMReg());
a61af66fc99e Initial load
duke
parents:
diff changeset
346 map->set_callee_saved(VMRegImpl::stack2reg(rdi_off + num_rt_args), rdi->as_VMReg());
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
347 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
348 map->set_callee_saved(VMRegImpl::stack2reg(r8_off + num_rt_args), r8->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
349 map->set_callee_saved(VMRegImpl::stack2reg(r9_off + num_rt_args), r9->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
350 map->set_callee_saved(VMRegImpl::stack2reg(r10_off + num_rt_args), r10->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
351 map->set_callee_saved(VMRegImpl::stack2reg(r11_off + num_rt_args), r11->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
352 map->set_callee_saved(VMRegImpl::stack2reg(r12_off + num_rt_args), r12->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
353 map->set_callee_saved(VMRegImpl::stack2reg(r13_off + num_rt_args), r13->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
354 map->set_callee_saved(VMRegImpl::stack2reg(r14_off + num_rt_args), r14->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
355 map->set_callee_saved(VMRegImpl::stack2reg(r15_off + num_rt_args), r15->as_VMReg());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
356
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
357 // This is stupid but needed.
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
358 map->set_callee_saved(VMRegImpl::stack2reg(raxH_off + num_rt_args), rax->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
359 map->set_callee_saved(VMRegImpl::stack2reg(rcxH_off + num_rt_args), rcx->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
360 map->set_callee_saved(VMRegImpl::stack2reg(rdxH_off + num_rt_args), rdx->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
361 map->set_callee_saved(VMRegImpl::stack2reg(rbxH_off + num_rt_args), rbx->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
362 map->set_callee_saved(VMRegImpl::stack2reg(rsiH_off + num_rt_args), rsi->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
363 map->set_callee_saved(VMRegImpl::stack2reg(rdiH_off + num_rt_args), rdi->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
364
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
365 map->set_callee_saved(VMRegImpl::stack2reg(r8H_off + num_rt_args), r8->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
366 map->set_callee_saved(VMRegImpl::stack2reg(r9H_off + num_rt_args), r9->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
367 map->set_callee_saved(VMRegImpl::stack2reg(r10H_off + num_rt_args), r10->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
368 map->set_callee_saved(VMRegImpl::stack2reg(r11H_off + num_rt_args), r11->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
369 map->set_callee_saved(VMRegImpl::stack2reg(r12H_off + num_rt_args), r12->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
370 map->set_callee_saved(VMRegImpl::stack2reg(r13H_off + num_rt_args), r13->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
371 map->set_callee_saved(VMRegImpl::stack2reg(r14H_off + num_rt_args), r14->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
372 map->set_callee_saved(VMRegImpl::stack2reg(r15H_off + num_rt_args), r15->as_VMReg()->next());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
373 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
374
a61af66fc99e Initial load
duke
parents:
diff changeset
375 if (save_fpu_registers) {
a61af66fc99e Initial load
duke
parents:
diff changeset
376 if (UseSSE < 2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
377 int fpu_off = float_regs_as_doubles_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
378 for (int n = 0; n < FrameMap::nof_fpu_regs; n++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
379 VMReg fpu_name_0 = FrameMap::fpu_regname(n);
a61af66fc99e Initial load
duke
parents:
diff changeset
380 map->set_callee_saved(VMRegImpl::stack2reg(fpu_off + num_rt_args), fpu_name_0);
a61af66fc99e Initial load
duke
parents:
diff changeset
381 // %%% This is really a waste but we'll keep things as they were for now
a61af66fc99e Initial load
duke
parents:
diff changeset
382 if (true) {
a61af66fc99e Initial load
duke
parents:
diff changeset
383 map->set_callee_saved(VMRegImpl::stack2reg(fpu_off + 1 + num_rt_args), fpu_name_0->next());
a61af66fc99e Initial load
duke
parents:
diff changeset
384 }
a61af66fc99e Initial load
duke
parents:
diff changeset
385 fpu_off += 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
386 }
a61af66fc99e Initial load
duke
parents:
diff changeset
387 assert(fpu_off == fpu_state_off, "incorrect number of fpu stack slots");
a61af66fc99e Initial load
duke
parents:
diff changeset
388 }
a61af66fc99e Initial load
duke
parents:
diff changeset
389
a61af66fc99e Initial load
duke
parents:
diff changeset
390 if (UseSSE >= 2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
391 int xmm_off = xmm_regs_as_doubles_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
392 for (int n = 0; n < FrameMap::nof_xmm_regs; n++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
393 VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg();
a61af66fc99e Initial load
duke
parents:
diff changeset
394 map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + num_rt_args), xmm_name_0);
a61af66fc99e Initial load
duke
parents:
diff changeset
395 // %%% This is really a waste but we'll keep things as they were for now
a61af66fc99e Initial load
duke
parents:
diff changeset
396 if (true) {
a61af66fc99e Initial load
duke
parents:
diff changeset
397 map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + 1 + num_rt_args), xmm_name_0->next());
a61af66fc99e Initial load
duke
parents:
diff changeset
398 }
a61af66fc99e Initial load
duke
parents:
diff changeset
399 xmm_off += 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
400 }
a61af66fc99e Initial load
duke
parents:
diff changeset
401 assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers");
a61af66fc99e Initial load
duke
parents:
diff changeset
402
a61af66fc99e Initial load
duke
parents:
diff changeset
403 } else if (UseSSE == 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
404 int xmm_off = xmm_regs_as_doubles_off;
a61af66fc99e Initial load
duke
parents:
diff changeset
405 for (int n = 0; n < FrameMap::nof_xmm_regs; n++) {
a61af66fc99e Initial load
duke
parents:
diff changeset
406 VMReg xmm_name_0 = as_XMMRegister(n)->as_VMReg();
a61af66fc99e Initial load
duke
parents:
diff changeset
407 map->set_callee_saved(VMRegImpl::stack2reg(xmm_off + num_rt_args), xmm_name_0);
a61af66fc99e Initial load
duke
parents:
diff changeset
408 xmm_off += 2;
a61af66fc99e Initial load
duke
parents:
diff changeset
409 }
a61af66fc99e Initial load
duke
parents:
diff changeset
410 assert(xmm_off == float_regs_as_doubles_off, "incorrect number of xmm registers");
a61af66fc99e Initial load
duke
parents:
diff changeset
411 }
a61af66fc99e Initial load
duke
parents:
diff changeset
412 }
a61af66fc99e Initial load
duke
parents:
diff changeset
413
a61af66fc99e Initial load
duke
parents:
diff changeset
414 return map;
a61af66fc99e Initial load
duke
parents:
diff changeset
415 }
a61af66fc99e Initial load
duke
parents:
diff changeset
416
a61af66fc99e Initial load
duke
parents:
diff changeset
417 static OopMap* save_live_registers(StubAssembler* sasm, int num_rt_args,
a61af66fc99e Initial load
duke
parents:
diff changeset
418 bool save_fpu_registers = true) {
a61af66fc99e Initial load
duke
parents:
diff changeset
419 __ block_comment("save_live_registers");
a61af66fc99e Initial load
duke
parents:
diff changeset
420
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
421 __ pusha(); // integer registers
0
a61af66fc99e Initial load
duke
parents:
diff changeset
422
a61af66fc99e Initial load
duke
parents:
diff changeset
423 // assert(float_regs_as_doubles_off % 2 == 0, "misaligned offset");
a61af66fc99e Initial load
duke
parents:
diff changeset
424 // assert(xmm_regs_as_doubles_off % 2 == 0, "misaligned offset");
a61af66fc99e Initial load
duke
parents:
diff changeset
425
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
426 __ subptr(rsp, extra_space_offset * VMRegImpl::stack_slot_size);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
427
a61af66fc99e Initial load
duke
parents:
diff changeset
428 #ifdef ASSERT
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
429 __ movptr(Address(rsp, marker * VMRegImpl::stack_slot_size), (int32_t)0xfeedbeef);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
430 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
431
a61af66fc99e Initial load
duke
parents:
diff changeset
432 if (save_fpu_registers) {
a61af66fc99e Initial load
duke
parents:
diff changeset
433 if (UseSSE < 2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
434 // save FPU stack
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
435 __ fnsave(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
436 __ fwait();
a61af66fc99e Initial load
duke
parents:
diff changeset
437
a61af66fc99e Initial load
duke
parents:
diff changeset
438 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
439 Label ok;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
440 __ cmpw(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size), StubRoutines::fpu_cntrl_wrd_std());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
441 __ jccb(Assembler::equal, ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
442 __ stop("corrupted control word detected");
a61af66fc99e Initial load
duke
parents:
diff changeset
443 __ bind(ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
444 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
445
a61af66fc99e Initial load
duke
parents:
diff changeset
446 // Reset the control word to guard against exceptions being unmasked
a61af66fc99e Initial load
duke
parents:
diff changeset
447 // since fstp_d can cause FPU stack underflow exceptions. Write it
a61af66fc99e Initial load
duke
parents:
diff changeset
448 // into the on stack copy and then reload that to make sure that the
a61af66fc99e Initial load
duke
parents:
diff changeset
449 // current and future values are correct.
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
450 __ movw(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size), StubRoutines::fpu_cntrl_wrd_std());
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
451 __ frstor(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
452
a61af66fc99e Initial load
duke
parents:
diff changeset
453 // Save the FPU registers in de-opt-able form
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
454 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
455 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
456 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
457 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
458 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
459 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
460 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
461 __ fstp_d(Address(rsp, float_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
462 }
a61af66fc99e Initial load
duke
parents:
diff changeset
463
a61af66fc99e Initial load
duke
parents:
diff changeset
464 if (UseSSE >= 2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
465 // save XMM registers
a61af66fc99e Initial load
duke
parents:
diff changeset
466 // XMM registers can contain float or double values, but this is not known here,
a61af66fc99e Initial load
duke
parents:
diff changeset
467 // so always save them as doubles.
a61af66fc99e Initial load
duke
parents:
diff changeset
468 // note that float values are _not_ converted automatically, so for float values
a61af66fc99e Initial load
duke
parents:
diff changeset
469 // the second word contains only garbage data.
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
470 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0), xmm0);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
471 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8), xmm1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
472 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16), xmm2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
473 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24), xmm3);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
474 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32), xmm4);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
475 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40), xmm5);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
476 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48), xmm6);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
477 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56), xmm7);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
478 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
479 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 64), xmm8);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
480 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 72), xmm9);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
481 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 80), xmm10);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
482 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 88), xmm11);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
483 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 96), xmm12);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
484 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 104), xmm13);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
485 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 112), xmm14);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
486 __ movdbl(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 120), xmm15);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
487 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
488 } else if (UseSSE == 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
489 // save XMM registers as float because double not supported without SSE2
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
490 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0), xmm0);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
491 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8), xmm1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
492 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16), xmm2);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
493 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24), xmm3);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
494 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32), xmm4);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
495 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40), xmm5);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
496 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48), xmm6);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
497 __ movflt(Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56), xmm7);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
498 }
a61af66fc99e Initial load
duke
parents:
diff changeset
499 }
a61af66fc99e Initial load
duke
parents:
diff changeset
500
a61af66fc99e Initial load
duke
parents:
diff changeset
501 // FPU stack must be empty now
a61af66fc99e Initial load
duke
parents:
diff changeset
502 __ verify_FPU(0, "save_live_registers");
a61af66fc99e Initial load
duke
parents:
diff changeset
503
a61af66fc99e Initial load
duke
parents:
diff changeset
504 return generate_oop_map(sasm, num_rt_args, save_fpu_registers);
a61af66fc99e Initial load
duke
parents:
diff changeset
505 }
a61af66fc99e Initial load
duke
parents:
diff changeset
506
a61af66fc99e Initial load
duke
parents:
diff changeset
507
a61af66fc99e Initial load
duke
parents:
diff changeset
508 static void restore_fpu(StubAssembler* sasm, bool restore_fpu_registers = true) {
a61af66fc99e Initial load
duke
parents:
diff changeset
509 if (restore_fpu_registers) {
a61af66fc99e Initial load
duke
parents:
diff changeset
510 if (UseSSE >= 2) {
a61af66fc99e Initial load
duke
parents:
diff changeset
511 // restore XMM registers
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
512 __ movdbl(xmm0, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
513 __ movdbl(xmm1, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
514 __ movdbl(xmm2, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
515 __ movdbl(xmm3, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
516 __ movdbl(xmm4, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
517 __ movdbl(xmm5, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
518 __ movdbl(xmm6, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
519 __ movdbl(xmm7, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
520 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
521 __ movdbl(xmm8, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 64));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
522 __ movdbl(xmm9, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 72));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
523 __ movdbl(xmm10, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 80));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
524 __ movdbl(xmm11, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 88));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
525 __ movdbl(xmm12, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 96));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
526 __ movdbl(xmm13, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 104));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
527 __ movdbl(xmm14, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 112));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
528 __ movdbl(xmm15, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 120));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
529 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
530 } else if (UseSSE == 1) {
a61af66fc99e Initial load
duke
parents:
diff changeset
531 // restore XMM registers
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
532 __ movflt(xmm0, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 0));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
533 __ movflt(xmm1, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 8));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
534 __ movflt(xmm2, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 16));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
535 __ movflt(xmm3, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 24));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
536 __ movflt(xmm4, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 32));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
537 __ movflt(xmm5, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 40));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
538 __ movflt(xmm6, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 48));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
539 __ movflt(xmm7, Address(rsp, xmm_regs_as_doubles_off * VMRegImpl::stack_slot_size + 56));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
540 }
a61af66fc99e Initial load
duke
parents:
diff changeset
541
a61af66fc99e Initial load
duke
parents:
diff changeset
542 if (UseSSE < 2) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
543 __ frstor(Address(rsp, fpu_state_off * VMRegImpl::stack_slot_size));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
544 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
545 // check that FPU stack is really empty
a61af66fc99e Initial load
duke
parents:
diff changeset
546 __ verify_FPU(0, "restore_live_registers");
a61af66fc99e Initial load
duke
parents:
diff changeset
547 }
a61af66fc99e Initial load
duke
parents:
diff changeset
548
a61af66fc99e Initial load
duke
parents:
diff changeset
549 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
550 // check that FPU stack is really empty
a61af66fc99e Initial load
duke
parents:
diff changeset
551 __ verify_FPU(0, "restore_live_registers");
a61af66fc99e Initial load
duke
parents:
diff changeset
552 }
a61af66fc99e Initial load
duke
parents:
diff changeset
553
a61af66fc99e Initial load
duke
parents:
diff changeset
554 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
555 {
a61af66fc99e Initial load
duke
parents:
diff changeset
556 Label ok;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
557 __ cmpptr(Address(rsp, marker * VMRegImpl::stack_slot_size), (int32_t)0xfeedbeef);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
558 __ jcc(Assembler::equal, ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
559 __ stop("bad offsets in frame");
a61af66fc99e Initial load
duke
parents:
diff changeset
560 __ bind(ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
561 }
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
562 #endif // ASSERT
0
a61af66fc99e Initial load
duke
parents:
diff changeset
563
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
564 __ addptr(rsp, extra_space_offset * VMRegImpl::stack_slot_size);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
565 }
a61af66fc99e Initial load
duke
parents:
diff changeset
566
a61af66fc99e Initial load
duke
parents:
diff changeset
567
2662
440ceca8e3d7 Add exception handlers only to Invoke and Throw instructions. Deoptimize if there is an exception in a HotSpot runtime call.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2608
diff changeset
568 static void restore_live_registers(StubAssembler* sasm, bool restore_fpu_registers/* = true*/) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
569 __ block_comment("restore_live_registers");
a61af66fc99e Initial load
duke
parents:
diff changeset
570
a61af66fc99e Initial load
duke
parents:
diff changeset
571 restore_fpu(sasm, restore_fpu_registers);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
572 __ popa();
0
a61af66fc99e Initial load
duke
parents:
diff changeset
573 }
a61af66fc99e Initial load
duke
parents:
diff changeset
574
a61af66fc99e Initial load
duke
parents:
diff changeset
575
a61af66fc99e Initial load
duke
parents:
diff changeset
576 static void restore_live_registers_except_rax(StubAssembler* sasm, bool restore_fpu_registers = true) {
a61af66fc99e Initial load
duke
parents:
diff changeset
577 __ block_comment("restore_live_registers_except_rax");
a61af66fc99e Initial load
duke
parents:
diff changeset
578
a61af66fc99e Initial load
duke
parents:
diff changeset
579 restore_fpu(sasm, restore_fpu_registers);
a61af66fc99e Initial load
duke
parents:
diff changeset
580
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
581 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
582 __ movptr(r15, Address(rsp, 0));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
583 __ movptr(r14, Address(rsp, wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
584 __ movptr(r13, Address(rsp, 2 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
585 __ movptr(r12, Address(rsp, 3 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
586 __ movptr(r11, Address(rsp, 4 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
587 __ movptr(r10, Address(rsp, 5 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
588 __ movptr(r9, Address(rsp, 6 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
589 __ movptr(r8, Address(rsp, 7 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
590 __ movptr(rdi, Address(rsp, 8 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
591 __ movptr(rsi, Address(rsp, 9 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
592 __ movptr(rbp, Address(rsp, 10 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
593 // skip rsp
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
594 __ movptr(rbx, Address(rsp, 12 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
595 __ movptr(rdx, Address(rsp, 13 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
596 __ movptr(rcx, Address(rsp, 14 * wordSize));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
597
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
598 __ addptr(rsp, 16 * wordSize);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
599 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
600
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
601 __ pop(rdi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
602 __ pop(rsi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
603 __ pop(rbp);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
604 __ pop(rbx); // skip this value
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
605 __ pop(rbx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
606 __ pop(rdx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
607 __ pop(rcx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
608 __ addptr(rsp, BytesPerWord);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
609 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
610 }
a61af66fc99e Initial load
duke
parents:
diff changeset
611
a61af66fc99e Initial load
duke
parents:
diff changeset
612
a61af66fc99e Initial load
duke
parents:
diff changeset
613 void Runtime1::initialize_pd() {
a61af66fc99e Initial load
duke
parents:
diff changeset
614 // nothing to do
a61af66fc99e Initial load
duke
parents:
diff changeset
615 }
a61af66fc99e Initial load
duke
parents:
diff changeset
616
a61af66fc99e Initial load
duke
parents:
diff changeset
617
a61af66fc99e Initial load
duke
parents:
diff changeset
618 // target: the entry point of the method that creates and posts the exception oop
a61af66fc99e Initial load
duke
parents:
diff changeset
619 // has_argument: true if the exception needs an argument (passed on stack because registers must be preserved)
a61af66fc99e Initial load
duke
parents:
diff changeset
620
a61af66fc99e Initial load
duke
parents:
diff changeset
621 OopMapSet* Runtime1::generate_exception_throw(StubAssembler* sasm, address target, bool has_argument) {
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
622 OopMapSet* oop_maps = new OopMapSet();
4559
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
623 #ifdef GRAAL
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
624 OopMap* oop_map = save_live_registers(sasm, 1);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
625
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
626 // now all registers are saved and can be used freely
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
627 // verify that no old value is used accidentally
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
628 __ invalidate_registers(true, true, true, true, true, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
629
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
630 // registers used by this stub
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
631 const Register temp_reg = rbx;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
632
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
633 // load argument for exception that is passed as an argument into the stub
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
634 if (has_argument) {
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
635 __ movptr(c_rarg1, r10);
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
636 }
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
637 int call_offset = __ call_RT(noreg, noreg, target, has_argument ? 1 : 0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
638
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
639 oop_maps->add_gc_map(call_offset, oop_map);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
640 #else
0
a61af66fc99e Initial load
duke
parents:
diff changeset
641 // preserve all registers
a61af66fc99e Initial load
duke
parents:
diff changeset
642 int num_rt_args = has_argument ? 2 : 1;
a61af66fc99e Initial load
duke
parents:
diff changeset
643 OopMap* oop_map = save_live_registers(sasm, num_rt_args);
a61af66fc99e Initial load
duke
parents:
diff changeset
644
a61af66fc99e Initial load
duke
parents:
diff changeset
645 // now all registers are saved and can be used freely
a61af66fc99e Initial load
duke
parents:
diff changeset
646 // verify that no old value is used accidentally
a61af66fc99e Initial load
duke
parents:
diff changeset
647 __ invalidate_registers(true, true, true, true, true, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
648
a61af66fc99e Initial load
duke
parents:
diff changeset
649 // registers used by this stub
a61af66fc99e Initial load
duke
parents:
diff changeset
650 const Register temp_reg = rbx;
a61af66fc99e Initial load
duke
parents:
diff changeset
651
a61af66fc99e Initial load
duke
parents:
diff changeset
652 // load argument for exception that is passed as an argument into the stub
a61af66fc99e Initial load
duke
parents:
diff changeset
653 if (has_argument) {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
654 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
655 __ movptr(c_rarg1, Address(rbp, 2*BytesPerWord));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
656 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
657 __ movptr(temp_reg, Address(rbp, 2*BytesPerWord));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
658 __ push(temp_reg);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
659 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
660 }
a61af66fc99e Initial load
duke
parents:
diff changeset
661 int call_offset = __ call_RT(noreg, noreg, target, num_rt_args - 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
662
a61af66fc99e Initial load
duke
parents:
diff changeset
663 oop_maps->add_gc_map(call_offset, oop_map);
4559
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
664 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
665
a61af66fc99e Initial load
duke
parents:
diff changeset
666 __ stop("should not reach here");
a61af66fc99e Initial load
duke
parents:
diff changeset
667
a61af66fc99e Initial load
duke
parents:
diff changeset
668 return oop_maps;
a61af66fc99e Initial load
duke
parents:
diff changeset
669 }
a61af66fc99e Initial load
duke
parents:
diff changeset
670
a61af66fc99e Initial load
duke
parents:
diff changeset
671
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
672 OopMapSet* Runtime1::generate_handle_exception(StubID id, StubAssembler *sasm) {
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
673 __ block_comment("generate_handle_exception");
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
674
0
a61af66fc99e Initial load
duke
parents:
diff changeset
675 // incoming parameters
a61af66fc99e Initial load
duke
parents:
diff changeset
676 const Register exception_oop = rax;
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
677 const Register exception_pc = rdx;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
678 // other registers used in this stub
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
679 const Register thread = NOT_LP64(rdi) LP64_ONLY(r15_thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
680
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
681 // Save registers, if required.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
682 OopMapSet* oop_maps = new OopMapSet();
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
683 OopMap* oop_map = NULL;
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
684 switch (id) {
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
685 case forward_exception_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
686 // We're handling an exception in the context of a compiled frame.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
687 // The registers have been saved in the standard places. Perform
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
688 // an exception lookup in the caller and dispatch to the handler
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
689 // if found. Otherwise unwind and dispatch to the callers
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
690 // exception handler.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
691 oop_map = generate_oop_map(sasm, 1 /*thread*/);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
692
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
693 // load and clear pending exception oop into RAX
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
694 __ movptr(exception_oop, Address(thread, Thread::pending_exception_offset()));
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
695 __ movptr(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
696
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
697 // load issuing PC (the return address for this stub) into rdx
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
698 __ movptr(exception_pc, Address(rbp, 1*BytesPerWord));
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
699
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
700 // make sure that the vm_results are cleared (may be unnecessary)
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
701 __ movptr(Address(thread, JavaThread::vm_result_offset()), NULL_WORD);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
702 __ movptr(Address(thread, JavaThread::vm_result_2_offset()), NULL_WORD);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
703 break;
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
704 case handle_exception_nofpu_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
705 case handle_exception_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
706 // At this point all registers MAY be live.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
707 oop_map = save_live_registers(sasm, 1 /*thread*/, id == handle_exception_nofpu_id);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
708 break;
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
709 case handle_exception_from_callee_id: {
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
710 // At this point all registers except exception oop (RAX) and
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
711 // exception pc (RDX) are dead.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
712 const int frame_size = 2 /*BP, return address*/ NOT_LP64(+ 1 /*thread*/) WIN64_ONLY(+ frame::arg_reg_save_area_bytes / BytesPerWord);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
713 oop_map = new OopMap(frame_size * VMRegImpl::slots_per_word, 0);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
714 sasm->set_frame_size(frame_size);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
715 WIN64_ONLY(__ subq(rsp, frame::arg_reg_save_area_bytes));
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
716 break;
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
717 }
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
718 default: ShouldNotReachHere();
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
719 }
0
a61af66fc99e Initial load
duke
parents:
diff changeset
720
a61af66fc99e Initial load
duke
parents:
diff changeset
721 #ifdef TIERED
a61af66fc99e Initial load
duke
parents:
diff changeset
722 // C2 can leave the fpu stack dirty
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
723 if (UseSSE < 2) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
724 __ empty_FPU_stack();
a61af66fc99e Initial load
duke
parents:
diff changeset
725 }
a61af66fc99e Initial load
duke
parents:
diff changeset
726 #endif // TIERED
a61af66fc99e Initial load
duke
parents:
diff changeset
727
a61af66fc99e Initial load
duke
parents:
diff changeset
728 // verify that only rax, and rdx is valid at this time
a61af66fc99e Initial load
duke
parents:
diff changeset
729 __ invalidate_registers(false, true, true, false, true, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
730 // verify that rax, contains a valid exception
a61af66fc99e Initial load
duke
parents:
diff changeset
731 __ verify_not_null_oop(exception_oop);
a61af66fc99e Initial load
duke
parents:
diff changeset
732
a61af66fc99e Initial load
duke
parents:
diff changeset
733 // load address of JavaThread object for thread-local data
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
734 NOT_LP64(__ get_thread(thread);)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
735
a61af66fc99e Initial load
duke
parents:
diff changeset
736 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
737 // check that fields in JavaThread for exception oop and issuing pc are
a61af66fc99e Initial load
duke
parents:
diff changeset
738 // empty before writing to them
a61af66fc99e Initial load
duke
parents:
diff changeset
739 Label oop_empty;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
740 __ cmpptr(Address(thread, JavaThread::exception_oop_offset()), (int32_t) NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
741 __ jcc(Assembler::equal, oop_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
742 __ stop("exception oop already set");
a61af66fc99e Initial load
duke
parents:
diff changeset
743 __ bind(oop_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
744
a61af66fc99e Initial load
duke
parents:
diff changeset
745 Label pc_empty;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
746 __ cmpptr(Address(thread, JavaThread::exception_pc_offset()), 0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
747 __ jcc(Assembler::equal, pc_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
748 __ stop("exception pc already set");
a61af66fc99e Initial load
duke
parents:
diff changeset
749 __ bind(pc_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
750 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
751
a61af66fc99e Initial load
duke
parents:
diff changeset
752 // save exception oop and issuing pc into JavaThread
a61af66fc99e Initial load
duke
parents:
diff changeset
753 // (exception handler will load it from here)
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
754 __ movptr(Address(thread, JavaThread::exception_oop_offset()), exception_oop);
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
755 __ movptr(Address(thread, JavaThread::exception_pc_offset()), exception_pc);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
756
a61af66fc99e Initial load
duke
parents:
diff changeset
757 // patch throwing pc into return address (has bci & oop map)
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
758 __ movptr(Address(rbp, 1*BytesPerWord), exception_pc);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
759
a61af66fc99e Initial load
duke
parents:
diff changeset
760 // compute the exception handler.
a61af66fc99e Initial load
duke
parents:
diff changeset
761 // the exception oop and the throwing pc are read from the fields in JavaThread
a61af66fc99e Initial load
duke
parents:
diff changeset
762 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, exception_handler_for_pc));
a61af66fc99e Initial load
duke
parents:
diff changeset
763 oop_maps->add_gc_map(call_offset, oop_map);
a61af66fc99e Initial load
duke
parents:
diff changeset
764
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
765 // rax: handler address
0
a61af66fc99e Initial load
duke
parents:
diff changeset
766 // will be the deopt blob if nmethod was deoptimized while we looked up
a61af66fc99e Initial load
duke
parents:
diff changeset
767 // handler regardless of whether handler existed in the nmethod.
a61af66fc99e Initial load
duke
parents:
diff changeset
768
a61af66fc99e Initial load
duke
parents:
diff changeset
769 // only rax, is valid at this time, all other registers have been destroyed by the runtime call
a61af66fc99e Initial load
duke
parents:
diff changeset
770 __ invalidate_registers(false, true, true, true, true, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
771
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
772 // patch the return address, this stub will directly return to the exception handler
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
773 __ movptr(Address(rbp, 1*BytesPerWord), rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
774
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
775 switch (id) {
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
776 case forward_exception_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
777 case handle_exception_nofpu_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
778 case handle_exception_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
779 // Restore the registers that were saved at the beginning.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
780 restore_live_registers(sasm, id == handle_exception_nofpu_id);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
781 break;
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
782 case handle_exception_from_callee_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
783 // WIN64_ONLY: No need to add frame::arg_reg_save_area_bytes to SP
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
784 // since we do a leave anyway.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
785
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
786 // Pop the return address since we are possibly changing SP (restoring from BP).
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
787 __ leave();
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
788 __ pop(rcx);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
789
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
790 // Restore SP from BP if the exception PC is a method handle call site.
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
791 NOT_LP64(__ get_thread(thread);)
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
792 __ cmpl(Address(thread, JavaThread::is_method_handle_return_offset()), 0);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
793 __ cmovptr(Assembler::notEqual, rsp, rbp_mh_SP_save);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
794 __ jmp(rcx); // jump to exception handler
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
795 break;
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
796 default: ShouldNotReachHere();
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
797 }
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
798
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
799 return oop_maps;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
800 }
a61af66fc99e Initial load
duke
parents:
diff changeset
801
a61af66fc99e Initial load
duke
parents:
diff changeset
802
a61af66fc99e Initial load
duke
parents:
diff changeset
803 void Runtime1::generate_unwind_exception(StubAssembler *sasm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
804 // incoming parameters
a61af66fc99e Initial load
duke
parents:
diff changeset
805 const Register exception_oop = rax;
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
806 // callee-saved copy of exception_oop during runtime call
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
807 const Register exception_oop_callee_saved = NOT_LP64(rsi) LP64_ONLY(r14);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
808 // other registers used in this stub
a61af66fc99e Initial load
duke
parents:
diff changeset
809 const Register exception_pc = rdx;
a61af66fc99e Initial load
duke
parents:
diff changeset
810 const Register handler_addr = rbx;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
811 const Register thread = NOT_LP64(rdi) LP64_ONLY(r15_thread);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
812
a61af66fc99e Initial load
duke
parents:
diff changeset
813 // verify that only rax, is valid at this time
a61af66fc99e Initial load
duke
parents:
diff changeset
814 __ invalidate_registers(false, true, true, true, true, true);
a61af66fc99e Initial load
duke
parents:
diff changeset
815
a61af66fc99e Initial load
duke
parents:
diff changeset
816 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
817 // check that fields in JavaThread for exception oop and issuing pc are empty
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
818 NOT_LP64(__ get_thread(thread);)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
819 Label oop_empty;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
820 __ cmpptr(Address(thread, JavaThread::exception_oop_offset()), 0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
821 __ jcc(Assembler::equal, oop_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
822 __ stop("exception oop must be empty");
a61af66fc99e Initial load
duke
parents:
diff changeset
823 __ bind(oop_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
824
a61af66fc99e Initial load
duke
parents:
diff changeset
825 Label pc_empty;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
826 __ cmpptr(Address(thread, JavaThread::exception_pc_offset()), 0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
827 __ jcc(Assembler::equal, pc_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
828 __ stop("exception pc must be empty");
a61af66fc99e Initial load
duke
parents:
diff changeset
829 __ bind(pc_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
830 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
831
a61af66fc99e Initial load
duke
parents:
diff changeset
832 // clear the FPU stack in case any FPU results are left behind
a61af66fc99e Initial load
duke
parents:
diff changeset
833 __ empty_FPU_stack();
a61af66fc99e Initial load
duke
parents:
diff changeset
834
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
835 // save exception_oop in callee-saved register to preserve it during runtime calls
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
836 __ verify_not_null_oop(exception_oop);
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
837 __ movptr(exception_oop_callee_saved, exception_oop);
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
838
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
839 NOT_LP64(__ get_thread(thread);)
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
840 // Get return address (is on top of stack after leave).
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
841 __ movptr(exception_pc, Address(rsp, 0));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
842
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
843 // search the exception handler address of the caller (using the return address)
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
844 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::exception_handler_for_return_address), thread, exception_pc);
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
845 // rax: exception handler address of the caller
0
a61af66fc99e Initial load
duke
parents:
diff changeset
846
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
847 // Only RAX and RSI are valid at this time, all other registers have been destroyed by the call.
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
848 __ invalidate_registers(false, true, true, true, false, true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
849
a61af66fc99e Initial load
duke
parents:
diff changeset
850 // move result of call into correct register
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
851 __ movptr(handler_addr, rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
852
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
853 // Restore exception oop to RAX (required convention of exception handler).
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
854 __ movptr(exception_oop, exception_oop_callee_saved);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
855
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
856 // verify that there is really a valid exception in rax
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
857 __ verify_not_null_oop(exception_oop);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
858
a61af66fc99e Initial load
duke
parents:
diff changeset
859 // get throwing pc (= return address).
a61af66fc99e Initial load
duke
parents:
diff changeset
860 // rdx has been destroyed by the call, so it must be set again
a61af66fc99e Initial load
duke
parents:
diff changeset
861 // the pop is also necessary to simulate the effect of a ret(0)
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
862 __ pop(exception_pc);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
863
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
864 // Restore SP from BP if the exception PC is a method handle call site.
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
865 NOT_LP64(__ get_thread(thread);)
1368
93767e6a2dfd 6941529: SharedRuntime::raw_exception_handler_for_return_address must reset thread MethodHandle flag
twisti
parents: 1295
diff changeset
866 __ cmpl(Address(thread, JavaThread::is_method_handle_return_offset()), 0);
1564
61b2245abf36 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 1368
diff changeset
867 __ cmovptr(Assembler::notEqual, rsp, rbp_mh_SP_save);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
868
a61af66fc99e Initial load
duke
parents:
diff changeset
869 // continue at exception handler (return address removed)
a61af66fc99e Initial load
duke
parents:
diff changeset
870 // note: do *not* remove arguments when unwinding the
a61af66fc99e Initial load
duke
parents:
diff changeset
871 // activation since the caller assumes having
a61af66fc99e Initial load
duke
parents:
diff changeset
872 // all arguments on the stack when entering the
a61af66fc99e Initial load
duke
parents:
diff changeset
873 // runtime to determine the exception handler
a61af66fc99e Initial load
duke
parents:
diff changeset
874 // (GC happens at call site with arguments!)
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
875 // rax: exception oop
0
a61af66fc99e Initial load
duke
parents:
diff changeset
876 // rdx: throwing pc
1295
3cf667df43ef 6919934: JSR 292 needs to support x86 C1
twisti
parents: 647
diff changeset
877 // rbx: exception handler
0
a61af66fc99e Initial load
duke
parents:
diff changeset
878 __ jmp(handler_addr);
a61af66fc99e Initial load
duke
parents:
diff changeset
879 }
a61af66fc99e Initial load
duke
parents:
diff changeset
880
a61af66fc99e Initial load
duke
parents:
diff changeset
881
a61af66fc99e Initial load
duke
parents:
diff changeset
882 OopMapSet* Runtime1::generate_patching(StubAssembler* sasm, address target) {
a61af66fc99e Initial load
duke
parents:
diff changeset
883 // use the maximum number of runtime-arguments here because it is difficult to
a61af66fc99e Initial load
duke
parents:
diff changeset
884 // distinguish each RT-Call.
a61af66fc99e Initial load
duke
parents:
diff changeset
885 // Note: This number affects also the RT-Call in generate_handle_exception because
a61af66fc99e Initial load
duke
parents:
diff changeset
886 // the oop-map is shared for all calls.
a61af66fc99e Initial load
duke
parents:
diff changeset
887 const int num_rt_args = 2; // thread + dummy
a61af66fc99e Initial load
duke
parents:
diff changeset
888
a61af66fc99e Initial load
duke
parents:
diff changeset
889 DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
a61af66fc99e Initial load
duke
parents:
diff changeset
890 assert(deopt_blob != NULL, "deoptimization blob must have been created");
a61af66fc99e Initial load
duke
parents:
diff changeset
891
a61af66fc99e Initial load
duke
parents:
diff changeset
892 OopMap* oop_map = save_live_registers(sasm, num_rt_args);
a61af66fc99e Initial load
duke
parents:
diff changeset
893
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
894 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
895 const Register thread = r15_thread;
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
896 // No need to worry about dummy
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
897 __ mov(c_rarg0, thread);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
898 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
899 __ push(rax); // push dummy
0
a61af66fc99e Initial load
duke
parents:
diff changeset
900
a61af66fc99e Initial load
duke
parents:
diff changeset
901 const Register thread = rdi; // is callee-saved register (Visual C++ calling conventions)
a61af66fc99e Initial load
duke
parents:
diff changeset
902 // push java thread (becomes first argument of C function)
a61af66fc99e Initial load
duke
parents:
diff changeset
903 __ get_thread(thread);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
904 __ push(thread);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
905 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
906 __ set_last_Java_frame(thread, noreg, rbp, NULL);
a61af66fc99e Initial load
duke
parents:
diff changeset
907 // do the call
a61af66fc99e Initial load
duke
parents:
diff changeset
908 __ call(RuntimeAddress(target));
a61af66fc99e Initial load
duke
parents:
diff changeset
909 OopMapSet* oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
910 oop_maps->add_gc_map(__ offset(), oop_map);
a61af66fc99e Initial load
duke
parents:
diff changeset
911 // verify callee-saved register
a61af66fc99e Initial load
duke
parents:
diff changeset
912 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
913 guarantee(thread != rax, "change this code");
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
914 __ push(rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
915 { Label L;
a61af66fc99e Initial load
duke
parents:
diff changeset
916 __ get_thread(rax);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
917 __ cmpptr(thread, rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
918 __ jcc(Assembler::equal, L);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
919 __ stop("StubAssembler::call_RT: rdi/r15 not callee saved?");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
920 __ bind(L);
a61af66fc99e Initial load
duke
parents:
diff changeset
921 }
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
922 __ pop(rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
923 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
924 __ reset_last_Java_frame(thread, true, false);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
925 #ifndef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
926 __ pop(rcx); // discard thread arg
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
927 __ pop(rcx); // discard dummy
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
928 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
929
a61af66fc99e Initial load
duke
parents:
diff changeset
930 // check for pending exceptions
a61af66fc99e Initial load
duke
parents:
diff changeset
931 { Label L;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
932 __ cmpptr(Address(thread, Thread::pending_exception_offset()), (int32_t)NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
933 __ jcc(Assembler::equal, L);
a61af66fc99e Initial load
duke
parents:
diff changeset
934 // exception pending => remove activation and forward to exception handler
a61af66fc99e Initial load
duke
parents:
diff changeset
935
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
936 __ testptr(rax, rax); // have we deoptimized?
0
a61af66fc99e Initial load
duke
parents:
diff changeset
937 __ jump_cc(Assembler::equal,
a61af66fc99e Initial load
duke
parents:
diff changeset
938 RuntimeAddress(Runtime1::entry_for(Runtime1::forward_exception_id)));
a61af66fc99e Initial load
duke
parents:
diff changeset
939
a61af66fc99e Initial load
duke
parents:
diff changeset
940 // the deopt blob expects exceptions in the special fields of
a61af66fc99e Initial load
duke
parents:
diff changeset
941 // JavaThread, so copy and clear pending exception.
a61af66fc99e Initial load
duke
parents:
diff changeset
942
a61af66fc99e Initial load
duke
parents:
diff changeset
943 // load and clear pending exception
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
944 __ movptr(rax, Address(thread, Thread::pending_exception_offset()));
512
db4caa99ef11 6787106: Hotspot 32 bit build fails on platforms having different definitions for intptr_t & int32_t
xlu
parents: 380
diff changeset
945 __ movptr(Address(thread, Thread::pending_exception_offset()), NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
946
a61af66fc99e Initial load
duke
parents:
diff changeset
947 // check that there is really a valid exception
a61af66fc99e Initial load
duke
parents:
diff changeset
948 __ verify_not_null_oop(rax);
a61af66fc99e Initial load
duke
parents:
diff changeset
949
a61af66fc99e Initial load
duke
parents:
diff changeset
950 // load throwing pc: this is the return address of the stub
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
951 __ movptr(rdx, Address(rsp, return_off * VMRegImpl::stack_slot_size));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
952
a61af66fc99e Initial load
duke
parents:
diff changeset
953 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
954 // check that fields in JavaThread for exception oop and issuing pc are empty
a61af66fc99e Initial load
duke
parents:
diff changeset
955 Label oop_empty;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
956 __ cmpptr(Address(thread, JavaThread::exception_oop_offset()), (int32_t)NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
957 __ jcc(Assembler::equal, oop_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
958 __ stop("exception oop must be empty");
a61af66fc99e Initial load
duke
parents:
diff changeset
959 __ bind(oop_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
960
a61af66fc99e Initial load
duke
parents:
diff changeset
961 Label pc_empty;
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
962 __ cmpptr(Address(thread, JavaThread::exception_pc_offset()), (int32_t)NULL_WORD);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
963 __ jcc(Assembler::equal, pc_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
964 __ stop("exception pc must be empty");
a61af66fc99e Initial load
duke
parents:
diff changeset
965 __ bind(pc_empty);
a61af66fc99e Initial load
duke
parents:
diff changeset
966 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
967
a61af66fc99e Initial load
duke
parents:
diff changeset
968 // store exception oop and throwing pc to JavaThread
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
969 __ movptr(Address(thread, JavaThread::exception_oop_offset()), rax);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
970 __ movptr(Address(thread, JavaThread::exception_pc_offset()), rdx);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
971
a61af66fc99e Initial load
duke
parents:
diff changeset
972 restore_live_registers(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
973
a61af66fc99e Initial load
duke
parents:
diff changeset
974 __ leave();
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
975 __ addptr(rsp, BytesPerWord); // remove return address from stack
0
a61af66fc99e Initial load
duke
parents:
diff changeset
976
a61af66fc99e Initial load
duke
parents:
diff changeset
977 // Forward the exception directly to deopt blob. We can blow no
a61af66fc99e Initial load
duke
parents:
diff changeset
978 // registers and must leave throwing pc on the stack. A patch may
a61af66fc99e Initial load
duke
parents:
diff changeset
979 // have values live in registers so the entry point with the
a61af66fc99e Initial load
duke
parents:
diff changeset
980 // exception in tls.
a61af66fc99e Initial load
duke
parents:
diff changeset
981 __ jump(RuntimeAddress(deopt_blob->unpack_with_exception_in_tls()));
a61af66fc99e Initial load
duke
parents:
diff changeset
982
a61af66fc99e Initial load
duke
parents:
diff changeset
983 __ bind(L);
a61af66fc99e Initial load
duke
parents:
diff changeset
984 }
a61af66fc99e Initial load
duke
parents:
diff changeset
985
a61af66fc99e Initial load
duke
parents:
diff changeset
986
a61af66fc99e Initial load
duke
parents:
diff changeset
987 // Runtime will return true if the nmethod has been deoptimized during
a61af66fc99e Initial load
duke
parents:
diff changeset
988 // the patching process. In that case we must do a deopt reexecute instead.
a61af66fc99e Initial load
duke
parents:
diff changeset
989
a61af66fc99e Initial load
duke
parents:
diff changeset
990 Label reexecuteEntry, cont;
a61af66fc99e Initial load
duke
parents:
diff changeset
991
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
992 __ testptr(rax, rax); // have we deoptimized?
0
a61af66fc99e Initial load
duke
parents:
diff changeset
993 __ jcc(Assembler::equal, cont); // no
a61af66fc99e Initial load
duke
parents:
diff changeset
994
a61af66fc99e Initial load
duke
parents:
diff changeset
995 // Will reexecute. Proper return address is already on the stack we just restore
a61af66fc99e Initial load
duke
parents:
diff changeset
996 // registers, pop all of our frame but the return address and jump to the deopt blob
a61af66fc99e Initial load
duke
parents:
diff changeset
997 restore_live_registers(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
998 __ leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
999 __ jump(RuntimeAddress(deopt_blob->unpack_with_reexecution()));
a61af66fc99e Initial load
duke
parents:
diff changeset
1000
a61af66fc99e Initial load
duke
parents:
diff changeset
1001 __ bind(cont);
a61af66fc99e Initial load
duke
parents:
diff changeset
1002 restore_live_registers(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1003 __ leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
1004 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1005
a61af66fc99e Initial load
duke
parents:
diff changeset
1006 return oop_maps;
a61af66fc99e Initial load
duke
parents:
diff changeset
1007 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1008
a61af66fc99e Initial load
duke
parents:
diff changeset
1009 OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1010
a61af66fc99e Initial load
duke
parents:
diff changeset
1011 // for better readability
a61af66fc99e Initial load
duke
parents:
diff changeset
1012 const bool must_gc_arguments = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1013 const bool dont_gc_arguments = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1014
a61af66fc99e Initial load
duke
parents:
diff changeset
1015 // default value; overwritten for some optimized stubs that are called from methods that do not use the fpu
a61af66fc99e Initial load
duke
parents:
diff changeset
1016 bool save_fpu_registers = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
1017
a61af66fc99e Initial load
duke
parents:
diff changeset
1018 // stub code & info for the different stubs
a61af66fc99e Initial load
duke
parents:
diff changeset
1019 OopMapSet* oop_maps = NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
1020 switch (id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1021 case forward_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1022 {
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1023 oop_maps = generate_handle_exception(id, sasm);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1024 __ leave();
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1025 __ ret(0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1026 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1027 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1028
a61af66fc99e Initial load
duke
parents:
diff changeset
1029 case new_instance_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1030 case fast_new_instance_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1031 case fast_new_instance_init_check_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1032 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1033 Register klass = rdx; // Incoming
a61af66fc99e Initial load
duke
parents:
diff changeset
1034 Register obj = rax; // Result
a61af66fc99e Initial load
duke
parents:
diff changeset
1035
a61af66fc99e Initial load
duke
parents:
diff changeset
1036 if (id == new_instance_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1037 __ set_info("new_instance", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1038 } else if (id == fast_new_instance_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1039 __ set_info("fast new_instance", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1040 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1041 assert(id == fast_new_instance_init_check_id, "bad StubID");
a61af66fc99e Initial load
duke
parents:
diff changeset
1042 __ set_info("fast new_instance init check", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1043 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1044
a61af66fc99e Initial load
duke
parents:
diff changeset
1045 if ((id == fast_new_instance_id || id == fast_new_instance_init_check_id) &&
a61af66fc99e Initial load
duke
parents:
diff changeset
1046 UseTLAB && FastTLABRefill) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1047 Label slow_path;
a61af66fc99e Initial load
duke
parents:
diff changeset
1048 Register obj_size = rcx;
a61af66fc99e Initial load
duke
parents:
diff changeset
1049 Register t1 = rbx;
a61af66fc99e Initial load
duke
parents:
diff changeset
1050 Register t2 = rsi;
a61af66fc99e Initial load
duke
parents:
diff changeset
1051 assert_different_registers(klass, obj, obj_size, t1, t2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1052
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1053 __ push(rdi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1054 __ push(rbx);
5618
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1055 #ifdef GRAAL
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1056 __ push(rcx);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1057 __ push(rsi);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1058 #endif
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1059
a61af66fc99e Initial load
duke
parents:
diff changeset
1060 if (id == fast_new_instance_init_check_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1061 // make sure the klass is initialized
4771
kvn
parents: 4739 4762
diff changeset
1062 __ cmpb(Address(klass, instanceKlass::init_state_offset()), instanceKlass::fully_initialized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1063 __ jcc(Assembler::notEqual, slow_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
1064 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1065
a61af66fc99e Initial load
duke
parents:
diff changeset
1066 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1067 // assert object can be fast path allocated
a61af66fc99e Initial load
duke
parents:
diff changeset
1068 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1069 Label ok, not_ok;
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1070 __ movl(obj_size, Address(klass, Klass::layout_helper_offset()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1071 __ cmpl(obj_size, 0); // make sure it's an instance (LH > 0)
a61af66fc99e Initial load
duke
parents:
diff changeset
1072 __ jcc(Assembler::lessEqual, not_ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
1073 __ testl(obj_size, Klass::_lh_instance_slow_path_bit);
a61af66fc99e Initial load
duke
parents:
diff changeset
1074 __ jcc(Assembler::zero, ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
1075 __ bind(not_ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
1076 __ stop("assert(can be fast path allocated)");
a61af66fc99e Initial load
duke
parents:
diff changeset
1077 __ should_not_reach_here();
a61af66fc99e Initial load
duke
parents:
diff changeset
1078 __ bind(ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
1079 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1080 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1081
a61af66fc99e Initial load
duke
parents:
diff changeset
1082 // if we got here then the TLAB allocation failed, so try
a61af66fc99e Initial load
duke
parents:
diff changeset
1083 // refilling the TLAB or allocating directly from eden.
a61af66fc99e Initial load
duke
parents:
diff changeset
1084 Label retry_tlab, try_eden;
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1085 const Register thread =
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1086 __ tlab_refill(retry_tlab, try_eden, slow_path); // does not destroy rdx (klass), returns rdi
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1087
a61af66fc99e Initial load
duke
parents:
diff changeset
1088 __ bind(retry_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
1089
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1090 // get the instance size (size is postive so movl is fine for 64bit)
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1091 __ movl(obj_size, Address(klass, Klass::layout_helper_offset()));
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1092
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1093 __ tlab_allocate(obj, obj_size, 0, t1, t2, slow_path);
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1094
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1095 __ initialize_object(obj, klass, obj_size, 0, t1, t2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1096 __ verify_oop(obj);
5618
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1097 #ifdef GRAAL
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1098 __ pop(rsi);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1099 __ pop(rcx);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1100 #endif
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1101 __ pop(rbx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1102 __ pop(rdi);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1103 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1104
a61af66fc99e Initial load
duke
parents:
diff changeset
1105 __ bind(try_eden);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1106 // get the instance size (size is postive so movl is fine for 64bit)
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1107 __ movl(obj_size, Address(klass, Klass::layout_helper_offset()));
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1108
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1109 __ eden_allocate(obj, obj_size, 0, t1, slow_path);
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1110 __ incr_allocated_bytes(thread, obj_size, 0);
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1111
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1112 __ initialize_object(obj, klass, obj_size, 0, t1, t2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1113 __ verify_oop(obj);
5618
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1114 #ifdef GRAAL
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1115 __ pop(rsi);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1116 __ pop(rcx);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1117 #endif
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1118 __ pop(rbx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1119 __ pop(rdi);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1120 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1121
a61af66fc99e Initial load
duke
parents:
diff changeset
1122 __ bind(slow_path);
5618
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1123 #ifdef GRAAL
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1124 __ pop(rsi);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1125 __ pop(rcx);
60ca7d300b8f reverted to using fast_new_instance_init_check_id stub to use fast TLAB refilling
Doug Simon <doug.simon@oracle.com>
parents: 5593
diff changeset
1126 #endif
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1127 __ pop(rbx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1128 __ pop(rdi);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1129 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1130
a61af66fc99e Initial load
duke
parents:
diff changeset
1131 __ enter();
a61af66fc99e Initial load
duke
parents:
diff changeset
1132 OopMap* map = save_live_registers(sasm, 2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1133 int call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_instance), klass);
a61af66fc99e Initial load
duke
parents:
diff changeset
1134 oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
1135 oop_maps->add_gc_map(call_offset, map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1136 restore_live_registers_except_rax(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1137 __ verify_oop(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1138 __ leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
1139 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1140
a61af66fc99e Initial load
duke
parents:
diff changeset
1141 // rax,: new instance
a61af66fc99e Initial load
duke
parents:
diff changeset
1142 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1143
a61af66fc99e Initial load
duke
parents:
diff changeset
1144 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1145
a61af66fc99e Initial load
duke
parents:
diff changeset
1146 case counter_overflow_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1147 {
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1681
diff changeset
1148 Register bci = rax, method = rbx;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1149 __ enter();
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1681
diff changeset
1150 OopMap* map = save_live_registers(sasm, 3);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1151 // Retrieve bci
a61af66fc99e Initial load
duke
parents:
diff changeset
1152 __ movl(bci, Address(rbp, 2*BytesPerWord));
1783
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1681
diff changeset
1153 // And a pointer to the methodOop
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1681
diff changeset
1154 __ movptr(method, Address(rbp, 3*BytesPerWord));
d5d065957597 6953144: Tiered compilation
iveresov
parents: 1681
diff changeset
1155 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, counter_overflow), bci, method);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1156 oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
1157 oop_maps->add_gc_map(call_offset, map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1158 restore_live_registers(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1159 __ leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
1160 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1161 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1162 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1163
a61af66fc99e Initial load
duke
parents:
diff changeset
1164 case new_type_array_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1165 case new_object_array_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1166 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1167 Register length = rbx; // Incoming
a61af66fc99e Initial load
duke
parents:
diff changeset
1168 Register klass = rdx; // Incoming
a61af66fc99e Initial load
duke
parents:
diff changeset
1169 Register obj = rax; // Result
a61af66fc99e Initial load
duke
parents:
diff changeset
1170
a61af66fc99e Initial load
duke
parents:
diff changeset
1171 if (id == new_type_array_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1172 __ set_info("new_type_array", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1173 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1174 __ set_info("new_object_array", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1175 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1176
a61af66fc99e Initial load
duke
parents:
diff changeset
1177 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1178 // assert object type is really an array of the proper kind
a61af66fc99e Initial load
duke
parents:
diff changeset
1179 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1180 Label ok;
a61af66fc99e Initial load
duke
parents:
diff changeset
1181 Register t0 = obj;
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1182 __ movl(t0, Address(klass, Klass::layout_helper_offset()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1183 __ sarl(t0, Klass::_lh_array_tag_shift);
a61af66fc99e Initial load
duke
parents:
diff changeset
1184 int tag = ((id == new_type_array_id)
a61af66fc99e Initial load
duke
parents:
diff changeset
1185 ? Klass::_lh_array_tag_type_value
a61af66fc99e Initial load
duke
parents:
diff changeset
1186 : Klass::_lh_array_tag_obj_value);
a61af66fc99e Initial load
duke
parents:
diff changeset
1187 __ cmpl(t0, tag);
a61af66fc99e Initial load
duke
parents:
diff changeset
1188 __ jcc(Assembler::equal, ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
1189 __ stop("assert(is an array klass)");
a61af66fc99e Initial load
duke
parents:
diff changeset
1190 __ should_not_reach_here();
a61af66fc99e Initial load
duke
parents:
diff changeset
1191 __ bind(ok);
a61af66fc99e Initial load
duke
parents:
diff changeset
1192 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1193 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
1194
a61af66fc99e Initial load
duke
parents:
diff changeset
1195 if (UseTLAB && FastTLABRefill) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1196 Register arr_size = rsi;
a61af66fc99e Initial load
duke
parents:
diff changeset
1197 Register t1 = rcx; // must be rcx for use as shift count
a61af66fc99e Initial load
duke
parents:
diff changeset
1198 Register t2 = rdi;
a61af66fc99e Initial load
duke
parents:
diff changeset
1199 Label slow_path;
a61af66fc99e Initial load
duke
parents:
diff changeset
1200 assert_different_registers(length, klass, obj, arr_size, t1, t2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1201
a61af66fc99e Initial load
duke
parents:
diff changeset
1202 // check that array length is small enough for fast path.
a61af66fc99e Initial load
duke
parents:
diff changeset
1203 __ cmpl(length, C1_MacroAssembler::max_array_allocation_length);
a61af66fc99e Initial load
duke
parents:
diff changeset
1204 __ jcc(Assembler::above, slow_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
1205
a61af66fc99e Initial load
duke
parents:
diff changeset
1206 // if we got here then the TLAB allocation failed, so try
a61af66fc99e Initial load
duke
parents:
diff changeset
1207 // refilling the TLAB or allocating directly from eden.
a61af66fc99e Initial load
duke
parents:
diff changeset
1208 Label retry_tlab, try_eden;
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1209 const Register thread =
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1210 __ tlab_refill(retry_tlab, try_eden, slow_path); // preserves rbx & rdx, returns rdi
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1211
a61af66fc99e Initial load
duke
parents:
diff changeset
1212 __ bind(retry_tlab);
a61af66fc99e Initial load
duke
parents:
diff changeset
1213
a61af66fc99e Initial load
duke
parents:
diff changeset
1214 // get the allocation size: round_up(hdr + length << (layout_helper & 0x1F))
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1215 // since size is positive movl does right thing on 64bit
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1216 __ movl(t1, Address(klass, Klass::layout_helper_offset()));
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1217 // since size is postive movl does right thing on 64bit
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1218 __ movl(arr_size, length);
a61af66fc99e Initial load
duke
parents:
diff changeset
1219 assert(t1 == rcx, "fixed register usage");
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1220 __ shlptr(arr_size /* by t1=rcx, mod 32 */);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1221 __ shrptr(t1, Klass::_lh_header_size_shift);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1222 __ andptr(t1, Klass::_lh_header_size_mask);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1223 __ addptr(arr_size, t1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1224 __ addptr(arr_size, MinObjAlignmentInBytesMask); // align up
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1225 __ andptr(arr_size, ~MinObjAlignmentInBytesMask);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1226
a61af66fc99e Initial load
duke
parents:
diff changeset
1227 __ tlab_allocate(obj, arr_size, 0, t1, t2, slow_path); // preserves arr_size
a61af66fc99e Initial load
duke
parents:
diff changeset
1228
a61af66fc99e Initial load
duke
parents:
diff changeset
1229 __ initialize_header(obj, klass, length, t1, t2);
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1230 __ movb(t1, Address(klass, in_bytes(Klass::layout_helper_offset()) + (Klass::_lh_header_size_shift / BitsPerByte)));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1231 assert(Klass::_lh_header_size_shift % BitsPerByte == 0, "bytewise");
a61af66fc99e Initial load
duke
parents:
diff changeset
1232 assert(Klass::_lh_header_size_mask <= 0xFF, "bytewise");
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1233 __ andptr(t1, Klass::_lh_header_size_mask);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1234 __ subptr(arr_size, t1); // body length
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1235 __ addptr(t1, obj); // body start
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1236 __ initialize_body(t1, arr_size, 0, t2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1237 __ verify_oop(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1238 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1239
a61af66fc99e Initial load
duke
parents:
diff changeset
1240 __ bind(try_eden);
a61af66fc99e Initial load
duke
parents:
diff changeset
1241 // get the allocation size: round_up(hdr + length << (layout_helper & 0x1F))
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1242 // since size is positive movl does right thing on 64bit
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1243 __ movl(t1, Address(klass, Klass::layout_helper_offset()));
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1244 // since size is postive movl does right thing on 64bit
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1245 __ movl(arr_size, length);
a61af66fc99e Initial load
duke
parents:
diff changeset
1246 assert(t1 == rcx, "fixed register usage");
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1247 __ shlptr(arr_size /* by t1=rcx, mod 32 */);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1248 __ shrptr(t1, Klass::_lh_header_size_shift);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1249 __ andptr(t1, Klass::_lh_header_size_mask);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1250 __ addptr(arr_size, t1);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1251 __ addptr(arr_size, MinObjAlignmentInBytesMask); // align up
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1252 __ andptr(arr_size, ~MinObjAlignmentInBytesMask);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1253
a61af66fc99e Initial load
duke
parents:
diff changeset
1254 __ eden_allocate(obj, arr_size, 0, t1, slow_path); // preserves arr_size
2100
b1a2afa37ec4 7003271: Hotspot should track cumulative Java heap bytes allocated on a per-thread basis
phh
parents: 2002
diff changeset
1255 __ incr_allocated_bytes(thread, arr_size, 0);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1256
a61af66fc99e Initial load
duke
parents:
diff changeset
1257 __ initialize_header(obj, klass, length, t1, t2);
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1258 __ movb(t1, Address(klass, in_bytes(Klass::layout_helper_offset()) + (Klass::_lh_header_size_shift / BitsPerByte)));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1259 assert(Klass::_lh_header_size_shift % BitsPerByte == 0, "bytewise");
a61af66fc99e Initial load
duke
parents:
diff changeset
1260 assert(Klass::_lh_header_size_mask <= 0xFF, "bytewise");
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1261 __ andptr(t1, Klass::_lh_header_size_mask);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1262 __ subptr(arr_size, t1); // body length
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1263 __ addptr(t1, obj); // body start
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1264 __ initialize_body(t1, arr_size, 0, t2);
a61af66fc99e Initial load
duke
parents:
diff changeset
1265 __ verify_oop(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1266 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1267
a61af66fc99e Initial load
duke
parents:
diff changeset
1268 __ bind(slow_path);
a61af66fc99e Initial load
duke
parents:
diff changeset
1269 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1270
a61af66fc99e Initial load
duke
parents:
diff changeset
1271 __ enter();
a61af66fc99e Initial load
duke
parents:
diff changeset
1272 OopMap* map = save_live_registers(sasm, 3);
a61af66fc99e Initial load
duke
parents:
diff changeset
1273 int call_offset;
a61af66fc99e Initial load
duke
parents:
diff changeset
1274 if (id == new_type_array_id) {
a61af66fc99e Initial load
duke
parents:
diff changeset
1275 call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_type_array), klass, length);
a61af66fc99e Initial load
duke
parents:
diff changeset
1276 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
1277 call_offset = __ call_RT(obj, noreg, CAST_FROM_FN_PTR(address, new_object_array), klass, length);
a61af66fc99e Initial load
duke
parents:
diff changeset
1278 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1279
a61af66fc99e Initial load
duke
parents:
diff changeset
1280 oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
1281 oop_maps->add_gc_map(call_offset, map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1282 restore_live_registers_except_rax(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1283
a61af66fc99e Initial load
duke
parents:
diff changeset
1284 __ verify_oop(obj);
a61af66fc99e Initial load
duke
parents:
diff changeset
1285 __ leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
1286 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1287
a61af66fc99e Initial load
duke
parents:
diff changeset
1288 // rax,: new array
a61af66fc99e Initial load
duke
parents:
diff changeset
1289 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1290 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1291
a61af66fc99e Initial load
duke
parents:
diff changeset
1292 case new_multi_array_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1293 { StubFrame f(sasm, "new_multi_array", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1294 // rax,: klass
a61af66fc99e Initial load
duke
parents:
diff changeset
1295 // rbx,: rank
a61af66fc99e Initial load
duke
parents:
diff changeset
1296 // rcx: address of 1st dimension
a61af66fc99e Initial load
duke
parents:
diff changeset
1297 OopMap* map = save_live_registers(sasm, 4);
a61af66fc99e Initial load
duke
parents:
diff changeset
1298 int call_offset = __ call_RT(rax, noreg, CAST_FROM_FN_PTR(address, new_multi_array), rax, rbx, rcx);
a61af66fc99e Initial load
duke
parents:
diff changeset
1299
a61af66fc99e Initial load
duke
parents:
diff changeset
1300 oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
1301 oop_maps->add_gc_map(call_offset, map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1302 restore_live_registers_except_rax(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1303
a61af66fc99e Initial load
duke
parents:
diff changeset
1304 // rax,: new multi array
a61af66fc99e Initial load
duke
parents:
diff changeset
1305 __ verify_oop(rax);
a61af66fc99e Initial load
duke
parents:
diff changeset
1306 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1307 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1308
a61af66fc99e Initial load
duke
parents:
diff changeset
1309 case register_finalizer_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1310 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1311 __ set_info("register_finalizer", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1312
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1313 // This is called via call_runtime so the arguments
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1314 // will be place in C abi locations
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1315
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1316 #ifdef _LP64
4559
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
1317 #ifdef GRAAL
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
1318 __ verify_oop(j_rarg0);
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
1319 __ mov(rax, j_rarg0);
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
1320 #else
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1321 __ verify_oop(c_rarg0);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1322 __ mov(rax, c_rarg0);
4559
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
1323 #endif
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1324 #else
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1325 // The object is passed on the stack and we haven't pushed a
a61af66fc99e Initial load
duke
parents:
diff changeset
1326 // frame yet so it's one work away from top of stack.
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1327 __ movptr(rax, Address(rsp, 1 * BytesPerWord));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1328 __ verify_oop(rax);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1329 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1330
a61af66fc99e Initial load
duke
parents:
diff changeset
1331 // load the klass and check the has finalizer flag
a61af66fc99e Initial load
duke
parents:
diff changeset
1332 Label register_finalizer;
a61af66fc99e Initial load
duke
parents:
diff changeset
1333 Register t = rsi;
2002
ac637b7220d1 6985015: C1 needs to support compressed oops
iveresov
parents: 1972
diff changeset
1334 __ load_klass(t, rax);
4762
069ab3f976d3 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 4048
diff changeset
1335 __ movl(t, Address(t, Klass::access_flags_offset()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1336 __ testl(t, JVM_ACC_HAS_FINALIZER);
a61af66fc99e Initial load
duke
parents:
diff changeset
1337 __ jcc(Assembler::notZero, register_finalizer);
a61af66fc99e Initial load
duke
parents:
diff changeset
1338 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1339
a61af66fc99e Initial load
duke
parents:
diff changeset
1340 __ bind(register_finalizer);
a61af66fc99e Initial load
duke
parents:
diff changeset
1341 __ enter();
a61af66fc99e Initial load
duke
parents:
diff changeset
1342 OopMap* oop_map = save_live_registers(sasm, 2 /*num_rt_args */);
a61af66fc99e Initial load
duke
parents:
diff changeset
1343 int call_offset = __ call_RT(noreg, noreg,
a61af66fc99e Initial load
duke
parents:
diff changeset
1344 CAST_FROM_FN_PTR(address, SharedRuntime::register_finalizer), rax);
a61af66fc99e Initial load
duke
parents:
diff changeset
1345 oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
1346 oop_maps->add_gc_map(call_offset, oop_map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1347
a61af66fc99e Initial load
duke
parents:
diff changeset
1348 // Now restore all the live registers
a61af66fc99e Initial load
duke
parents:
diff changeset
1349 restore_live_registers(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1350
a61af66fc99e Initial load
duke
parents:
diff changeset
1351 __ leave();
a61af66fc99e Initial load
duke
parents:
diff changeset
1352 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1353 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1354 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1355
a61af66fc99e Initial load
duke
parents:
diff changeset
1356 case throw_range_check_failed_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1357 { StubFrame f(sasm, "range_check_failed", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1358 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_range_check_exception), true);
a61af66fc99e Initial load
duke
parents:
diff changeset
1359 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1360 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1361
a61af66fc99e Initial load
duke
parents:
diff changeset
1362 case throw_index_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1363 { StubFrame f(sasm, "index_range_check_failed", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1364 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_index_exception), true);
a61af66fc99e Initial load
duke
parents:
diff changeset
1365 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1366 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1367
a61af66fc99e Initial load
duke
parents:
diff changeset
1368 case throw_div0_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1369 { StubFrame f(sasm, "throw_div0_exception", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1370 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_div0_exception), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
1371 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1372 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1373
a61af66fc99e Initial load
duke
parents:
diff changeset
1374 case throw_null_pointer_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1375 { StubFrame f(sasm, "throw_null_pointer_exception", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1376 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_null_pointer_exception), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
1377 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1378 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1379
a61af66fc99e Initial load
duke
parents:
diff changeset
1380 case handle_exception_nofpu_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1381 case handle_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1382 { StubFrame f(sasm, "handle_exception", dont_gc_arguments);
2321
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1383 oop_maps = generate_handle_exception(id, sasm);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1384 }
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1385 break;
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1386
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1387 case handle_exception_from_callee_id:
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1388 { StubFrame f(sasm, "handle_exception_from_callee", dont_gc_arguments);
1b4e6a5d98e0 7012914: JSR 292 MethodHandlesTest C1: frame::verify_return_pc(return_address) failed: must be a return pc
twisti
parents: 2168
diff changeset
1389 oop_maps = generate_handle_exception(id, sasm);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1390 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1391 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1392
a61af66fc99e Initial load
duke
parents:
diff changeset
1393 case unwind_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1394 { __ set_info("unwind_exception", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1395 // note: no stubframe since we are about to leave the current
a61af66fc99e Initial load
duke
parents:
diff changeset
1396 // activation and we are calling a leaf VM function only.
a61af66fc99e Initial load
duke
parents:
diff changeset
1397 generate_unwind_exception(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1398 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1399 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1400
a61af66fc99e Initial load
duke
parents:
diff changeset
1401 case throw_array_store_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1402 { StubFrame f(sasm, "throw_array_store_exception", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1403 // tos + 0: link
a61af66fc99e Initial load
duke
parents:
diff changeset
1404 // + 1: return address
2168
e4fee0bdaa85 7008809: should report the class in ArrayStoreExceptions from compiled code
never
parents: 2100
diff changeset
1405 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_array_store_exception), true);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1406 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1407 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1408
a61af66fc99e Initial load
duke
parents:
diff changeset
1409 case throw_class_cast_exception_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1410 { StubFrame f(sasm, "throw_class_cast_exception", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1411 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_class_cast_exception), true);
a61af66fc99e Initial load
duke
parents:
diff changeset
1412 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1413 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1414
a61af66fc99e Initial load
duke
parents:
diff changeset
1415 case throw_incompatible_class_change_error_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1416 { StubFrame f(sasm, "throw_incompatible_class_cast_exception", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1417 oop_maps = generate_exception_throw(sasm, CAST_FROM_FN_PTR(address, throw_incompatible_class_change_error), false);
a61af66fc99e Initial load
duke
parents:
diff changeset
1418 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1419 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1420
a61af66fc99e Initial load
duke
parents:
diff changeset
1421 case slow_subtype_check_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1422 {
644
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1423 // Typical calling sequence:
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1424 // __ push(klass_RInfo); // object klass or other subclass
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1425 // __ push(sup_k_RInfo); // array element klass or other superclass
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1426 // __ call(slow_subtype_check);
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1427 // Note that the subclass is pushed first, and is therefore deepest.
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1428 // Previous versions of this code reversed the names 'sub' and 'super'.
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1429 // This was operationally harmless but made the code unreadable.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1430 enum layout {
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1431 rax_off, SLOT2(raxH_off)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1432 rcx_off, SLOT2(rcxH_off)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1433 rsi_off, SLOT2(rsiH_off)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1434 rdi_off, SLOT2(rdiH_off)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1435 // saved_rbp_off, SLOT2(saved_rbpH_off)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1436 return_off, SLOT2(returnH_off)
644
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1437 sup_k_off, SLOT2(sup_kH_off)
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1438 klass_off, SLOT2(superH_off)
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1439 framesize,
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1440 result_off = klass_off // deepest argument is also the return value
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1441 };
a61af66fc99e Initial load
duke
parents:
diff changeset
1442
a61af66fc99e Initial load
duke
parents:
diff changeset
1443 __ set_info("slow_subtype_check", dont_gc_arguments);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1444 __ push(rdi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1445 __ push(rsi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1446 __ push(rcx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1447 __ push(rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1448
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1449 // This is called by pushing args and not with C abi
644
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1450 __ movptr(rsi, Address(rsp, (klass_off) * VMRegImpl::stack_slot_size)); // subclass
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1451 __ movptr(rax, Address(rsp, (sup_k_off) * VMRegImpl::stack_slot_size)); // superclass
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1452
a61af66fc99e Initial load
duke
parents:
diff changeset
1453 Label miss;
4559
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
1454 #ifdef GRAAL
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
1455 Label success;
1423
760213a60e8b * rewrite of the code installation
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1414
diff changeset
1456 __ check_klass_subtype_fast_path(rsi, rax, rcx, &success, &miss, NULL);
4559
723df37192d6 Make it possible again to build a real client libjvm, drop the UseGraal flag.
Gilles Duboscq <duboscq@ssw.jku.at>
parents: 4223
diff changeset
1457 #endif
1423
760213a60e8b * rewrite of the code installation
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1414
diff changeset
1458
644
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1459 __ check_klass_subtype_slow_path(rsi, rax, rcx, rdi, NULL, &miss);
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1460
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1461 // fallthrough on success:
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
1462 #ifdef GRAAL
1423
760213a60e8b * rewrite of the code installation
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1414
diff changeset
1463 __ bind(success);
4977
532be189cf09 Reducing diff to hsx24
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4976
diff changeset
1464 #endif
644
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1465 __ movptr(Address(rsp, (result_off) * VMRegImpl::stack_slot_size), 1); // result
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1466 __ pop(rax);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1467 __ pop(rcx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1468 __ pop(rsi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1469 __ pop(rdi);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1470 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1471
a61af66fc99e Initial load
duke
parents:
diff changeset
1472 __ bind(miss);
644
c517646eef23 6813212: factor duplicated assembly code for general subclass check (for 6655638)
jrose
parents: 533
diff changeset
1473 __ movptr(Address(rsp, (result_off) * VMRegImpl::stack_slot_size), NULL_WORD); // result
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1474 __ pop(rax);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1475 __ pop(rcx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1476 __ pop(rsi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1477 __ pop(rdi);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1478 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1479 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1480 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1481
a61af66fc99e Initial load
duke
parents:
diff changeset
1482 case monitorenter_nofpu_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1483 save_fpu_registers = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1484 // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
1485 case monitorenter_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1486 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1487 StubFrame f(sasm, "monitorenter", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1488 OopMap* map = save_live_registers(sasm, 3, save_fpu_registers);
a61af66fc99e Initial load
duke
parents:
diff changeset
1489
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1490 // Called with store_parameter and not C abi
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1491
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1492 f.load_argument(1, rax); // rax,: object
a61af66fc99e Initial load
duke
parents:
diff changeset
1493 f.load_argument(0, rbx); // rbx,: lock address
a61af66fc99e Initial load
duke
parents:
diff changeset
1494
a61af66fc99e Initial load
duke
parents:
diff changeset
1495 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorenter), rax, rbx);
a61af66fc99e Initial load
duke
parents:
diff changeset
1496
a61af66fc99e Initial load
duke
parents:
diff changeset
1497 oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
1498 oop_maps->add_gc_map(call_offset, map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1499 restore_live_registers(sasm, save_fpu_registers);
a61af66fc99e Initial load
duke
parents:
diff changeset
1500 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1501 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1502
a61af66fc99e Initial load
duke
parents:
diff changeset
1503 case monitorexit_nofpu_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1504 save_fpu_registers = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
1505 // fall through
a61af66fc99e Initial load
duke
parents:
diff changeset
1506 case monitorexit_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1507 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1508 StubFrame f(sasm, "monitorexit", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1509 OopMap* map = save_live_registers(sasm, 2, save_fpu_registers);
a61af66fc99e Initial load
duke
parents:
diff changeset
1510
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1511 // Called with store_parameter and not C abi
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1512
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1513 f.load_argument(0, rax); // rax,: lock address
a61af66fc99e Initial load
duke
parents:
diff changeset
1514
a61af66fc99e Initial load
duke
parents:
diff changeset
1515 // note: really a leaf routine but must setup last java sp
a61af66fc99e Initial load
duke
parents:
diff changeset
1516 // => use call_RT for now (speed can be improved by
a61af66fc99e Initial load
duke
parents:
diff changeset
1517 // doing last java sp setup manually)
a61af66fc99e Initial load
duke
parents:
diff changeset
1518 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, monitorexit), rax);
a61af66fc99e Initial load
duke
parents:
diff changeset
1519
a61af66fc99e Initial load
duke
parents:
diff changeset
1520 oop_maps = new OopMapSet();
a61af66fc99e Initial load
duke
parents:
diff changeset
1521 oop_maps->add_gc_map(call_offset, map);
a61af66fc99e Initial load
duke
parents:
diff changeset
1522 restore_live_registers(sasm, save_fpu_registers);
4048
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1523 }
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1524 break;
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1525
4048
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1526 case deoptimize_id:
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1527 {
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1528 StubFrame f(sasm, "deoptimize", dont_gc_arguments);
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1529 const int num_rt_args = 1; // thread
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1530 OopMap* oop_map = save_live_registers(sasm, num_rt_args);
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1531 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, deoptimize));
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1532 oop_maps = new OopMapSet();
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1533 oop_maps->add_gc_map(call_offset, oop_map);
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1534 restore_live_registers(sasm);
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1535 DeoptimizationBlob* deopt_blob = SharedRuntime::deopt_blob();
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1536 assert(deopt_blob != NULL, "deoptimization blob must have been created");
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1537 __ leave();
cec1757a0134 7102657: JSR 292: C1 deoptimizes unlinked invokedynamic call sites infinitely
twisti
parents: 3899
diff changeset
1538 __ jump(RuntimeAddress(deopt_blob->unpack_with_reexecution()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1539 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1540 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1541
a61af66fc99e Initial load
duke
parents:
diff changeset
1542 case access_field_patching_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1543 { StubFrame f(sasm, "access_field_patching", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1544 // we should set up register map
a61af66fc99e Initial load
duke
parents:
diff changeset
1545 oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, access_field_patching));
a61af66fc99e Initial load
duke
parents:
diff changeset
1546 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1547 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1548
a61af66fc99e Initial load
duke
parents:
diff changeset
1549 case load_klass_patching_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1550 { StubFrame f(sasm, "load_klass_patching", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1551 // we should set up register map
a61af66fc99e Initial load
duke
parents:
diff changeset
1552 oop_maps = generate_patching(sasm, CAST_FROM_FN_PTR(address, move_klass_patching));
a61af66fc99e Initial load
duke
parents:
diff changeset
1553 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1554 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1555
a61af66fc99e Initial load
duke
parents:
diff changeset
1556 case dtrace_object_alloc_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1557 { // rax,: object
a61af66fc99e Initial load
duke
parents:
diff changeset
1558 StubFrame f(sasm, "dtrace_object_alloc", dont_gc_arguments);
a61af66fc99e Initial load
duke
parents:
diff changeset
1559 // we can't gc here so skip the oopmap but make sure that all
a61af66fc99e Initial load
duke
parents:
diff changeset
1560 // the live registers get saved.
a61af66fc99e Initial load
duke
parents:
diff changeset
1561 save_live_registers(sasm, 1);
a61af66fc99e Initial load
duke
parents:
diff changeset
1562
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1563 __ NOT_LP64(push(rax)) LP64_ONLY(mov(c_rarg0, rax));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1564 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc)));
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1565 NOT_LP64(__ pop(rax));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1566
a61af66fc99e Initial load
duke
parents:
diff changeset
1567 restore_live_registers(sasm);
a61af66fc99e Initial load
duke
parents:
diff changeset
1568 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1569 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1570
a61af66fc99e Initial load
duke
parents:
diff changeset
1571 case fpu2long_stub_id:
a61af66fc99e Initial load
duke
parents:
diff changeset
1572 {
a61af66fc99e Initial load
duke
parents:
diff changeset
1573 // rax, and rdx are destroyed, but should be free since the result is returned there
a61af66fc99e Initial load
duke
parents:
diff changeset
1574 // preserve rsi,ecx
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1575 __ push(rsi);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1576 __ push(rcx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1577 LP64_ONLY(__ push(rdx);)
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1578
a61af66fc99e Initial load
duke
parents:
diff changeset
1579 // check for NaN
a61af66fc99e Initial load
duke
parents:
diff changeset
1580 Label return0, do_return, return_min_jlong, do_convert;
a61af66fc99e Initial load
duke
parents:
diff changeset
1581
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1582 Address value_high_word(rsp, wordSize + 4);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1583 Address value_low_word(rsp, wordSize);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1584 Address result_high_word(rsp, 3*wordSize + 4);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1585 Address result_low_word(rsp, 3*wordSize);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1586
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1587 __ subptr(rsp, 32); // more than enough on 32bit
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1588 __ fst_d(value_low_word);
a61af66fc99e Initial load
duke
parents:
diff changeset
1589 __ movl(rax, value_high_word);
a61af66fc99e Initial load
duke
parents:
diff changeset
1590 __ andl(rax, 0x7ff00000);
a61af66fc99e Initial load
duke
parents:
diff changeset
1591 __ cmpl(rax, 0x7ff00000);
a61af66fc99e Initial load
duke
parents:
diff changeset
1592 __ jcc(Assembler::notEqual, do_convert);
a61af66fc99e Initial load
duke
parents:
diff changeset
1593 __ movl(rax, value_high_word);
a61af66fc99e Initial load
duke
parents:
diff changeset
1594 __ andl(rax, 0xfffff);
a61af66fc99e Initial load
duke
parents:
diff changeset
1595 __ orl(rax, value_low_word);
a61af66fc99e Initial load
duke
parents:
diff changeset
1596 __ jcc(Assembler::notZero, return0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1597
a61af66fc99e Initial load
duke
parents:
diff changeset
1598 __ bind(do_convert);
a61af66fc99e Initial load
duke
parents:
diff changeset
1599 __ fnstcw(Address(rsp, 0));
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1600 __ movzwl(rax, Address(rsp, 0));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1601 __ orl(rax, 0xc00);
a61af66fc99e Initial load
duke
parents:
diff changeset
1602 __ movw(Address(rsp, 2), rax);
a61af66fc99e Initial load
duke
parents:
diff changeset
1603 __ fldcw(Address(rsp, 2));
a61af66fc99e Initial load
duke
parents:
diff changeset
1604 __ fwait();
a61af66fc99e Initial load
duke
parents:
diff changeset
1605 __ fistp_d(result_low_word);
a61af66fc99e Initial load
duke
parents:
diff changeset
1606 __ fldcw(Address(rsp, 0));
a61af66fc99e Initial load
duke
parents:
diff changeset
1607 __ fwait();
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1608 // This gets the entire long in rax on 64bit
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1609 __ movptr(rax, result_low_word);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1610 // testing of high bits
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1611 __ movl(rdx, result_high_word);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1612 __ mov(rcx, rax);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1613 // What the heck is the point of the next instruction???
a61af66fc99e Initial load
duke
parents:
diff changeset
1614 __ xorl(rcx, 0x0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1615 __ movl(rsi, 0x80000000);
a61af66fc99e Initial load
duke
parents:
diff changeset
1616 __ xorl(rsi, rdx);
a61af66fc99e Initial load
duke
parents:
diff changeset
1617 __ orl(rcx, rsi);
a61af66fc99e Initial load
duke
parents:
diff changeset
1618 __ jcc(Assembler::notEqual, do_return);
a61af66fc99e Initial load
duke
parents:
diff changeset
1619 __ fldz();
a61af66fc99e Initial load
duke
parents:
diff changeset
1620 __ fcomp_d(value_low_word);
a61af66fc99e Initial load
duke
parents:
diff changeset
1621 __ fnstsw_ax();
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1622 #ifdef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1623 __ testl(rax, 0x4100); // ZF & CF == 0
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1624 __ jcc(Assembler::equal, return_min_jlong);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1625 #else
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1626 __ sahf();
a61af66fc99e Initial load
duke
parents:
diff changeset
1627 __ jcc(Assembler::above, return_min_jlong);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1628 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1629 // return max_jlong
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1630 #ifndef _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1631 __ movl(rdx, 0x7fffffff);
a61af66fc99e Initial load
duke
parents:
diff changeset
1632 __ movl(rax, 0xffffffff);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1633 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1634 __ mov64(rax, CONST64(0x7fffffffffffffff));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1635 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1636 __ jmp(do_return);
a61af66fc99e Initial load
duke
parents:
diff changeset
1637
a61af66fc99e Initial load
duke
parents:
diff changeset
1638 __ bind(return_min_jlong);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1639 #ifndef _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1640 __ movl(rdx, 0x80000000);
a61af66fc99e Initial load
duke
parents:
diff changeset
1641 __ xorl(rax, rax);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1642 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1643 __ mov64(rax, CONST64(0x8000000000000000));
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1644 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1645 __ jmp(do_return);
a61af66fc99e Initial load
duke
parents:
diff changeset
1646
a61af66fc99e Initial load
duke
parents:
diff changeset
1647 __ bind(return0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1648 __ fpop();
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1649 #ifndef _LP64
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1650 __ xorptr(rdx,rdx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1651 __ xorptr(rax,rax);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1652 #else
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1653 __ xorptr(rax, rax);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1654 #endif // _LP64
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1655
a61af66fc99e Initial load
duke
parents:
diff changeset
1656 __ bind(do_return);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1657 __ addptr(rsp, 32);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1658 LP64_ONLY(__ pop(rdx);)
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1659 __ pop(rcx);
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
1660 __ pop(rsi);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
1661 __ ret(0);
a61af66fc99e Initial load
duke
parents:
diff changeset
1662 }
a61af66fc99e Initial load
duke
parents:
diff changeset
1663 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
1664
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1665 #ifndef SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1666 case g1_pre_barrier_slow_id:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1667 {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1668 StubFrame f(sasm, "g1_pre_barrier", dont_gc_arguments);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1669 // arg0 : previous value of memory
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1670
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1671 BarrierSet* bs = Universe::heap()->barrier_set();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1672 if (bs->kind() != BarrierSet::G1SATBCTLogging) {
362
apetrusenko
parents: 304 342
diff changeset
1673 __ movptr(rax, (int)id);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1674 __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), rax);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1675 __ should_not_reach_here();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1676 break;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1677 }
362
apetrusenko
parents: 304 342
diff changeset
1678 __ push(rax);
apetrusenko
parents: 304 342
diff changeset
1679 __ push(rdx);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1680
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1681 const Register pre_val = rax;
362
apetrusenko
parents: 304 342
diff changeset
1682 const Register thread = NOT_LP64(rax) LP64_ONLY(r15_thread);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1683 const Register tmp = rdx;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1684
362
apetrusenko
parents: 304 342
diff changeset
1685 NOT_LP64(__ get_thread(thread);)
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1686
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1687 Address in_progress(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1688 PtrQueue::byte_offset_of_active()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1689
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1690 Address queue_index(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1691 PtrQueue::byte_offset_of_index()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1692 Address buffer(thread, in_bytes(JavaThread::satb_mark_queue_offset() +
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1693 PtrQueue::byte_offset_of_buf()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1694
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1695
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1696 Label done;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1697 Label runtime;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1698
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1699 // Can we store original value in the thread's buffer?
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1700
362
apetrusenko
parents: 304 342
diff changeset
1701 #ifdef _LP64
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1702 __ movslq(tmp, queue_index);
362
apetrusenko
parents: 304 342
diff changeset
1703 __ cmpq(tmp, 0);
apetrusenko
parents: 304 342
diff changeset
1704 #else
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1705 __ cmpl(queue_index, 0);
362
apetrusenko
parents: 304 342
diff changeset
1706 #endif
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1707 __ jcc(Assembler::equal, runtime);
362
apetrusenko
parents: 304 342
diff changeset
1708 #ifdef _LP64
apetrusenko
parents: 304 342
diff changeset
1709 __ subq(tmp, wordSize);
apetrusenko
parents: 304 342
diff changeset
1710 __ movl(queue_index, tmp);
apetrusenko
parents: 304 342
diff changeset
1711 __ addq(tmp, buffer);
apetrusenko
parents: 304 342
diff changeset
1712 #else
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1713 __ subl(queue_index, wordSize);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1714 __ movl(tmp, buffer);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1715 __ addl(tmp, queue_index);
362
apetrusenko
parents: 304 342
diff changeset
1716 #endif
apetrusenko
parents: 304 342
diff changeset
1717
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1718 // prev_val (rax)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1719 f.load_argument(0, pre_val);
362
apetrusenko
parents: 304 342
diff changeset
1720 __ movptr(Address(tmp, 0), pre_val);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1721 __ jmp(done);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1722
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1723 __ bind(runtime);
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1724 __ push(rcx);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1725 #ifdef _LP64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1726 __ push(r8);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1727 __ push(r9);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1728 __ push(r10);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1729 __ push(r11);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1730 # ifndef _WIN64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1731 __ push(rdi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1732 __ push(rsi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1733 # endif
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1734 #endif
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1735 // load the pre-value
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1736 f.load_argument(0, rcx);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1737 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_pre), rcx, thread);
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1738 #ifdef _LP64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1739 # ifndef _WIN64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1740 __ pop(rsi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1741 __ pop(rdi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1742 # endif
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1743 __ pop(r11);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1744 __ pop(r10);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1745 __ pop(r9);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1746 __ pop(r8);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1747 #endif
362
apetrusenko
parents: 304 342
diff changeset
1748 __ pop(rcx);
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1749 __ bind(done);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1750
362
apetrusenko
parents: 304 342
diff changeset
1751 __ pop(rdx);
apetrusenko
parents: 304 342
diff changeset
1752 __ pop(rax);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1753 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1754 break;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1755
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1756 case g1_post_barrier_slow_id:
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1757 {
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1758 StubFrame f(sasm, "g1_post_barrier", dont_gc_arguments);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1759
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1760
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1761 // arg0: store_address
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1762 Address store_addr(rbp, 2*BytesPerWord);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1763
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1764 BarrierSet* bs = Universe::heap()->barrier_set();
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1765 CardTableModRefBS* ct = (CardTableModRefBS*)bs;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1766 Label done;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1767 Label runtime;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1768
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1769 // At this point we know new_value is non-NULL and the new_value crosses regsion.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1770 // Must check to see if card is already dirty
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1771
362
apetrusenko
parents: 304 342
diff changeset
1772 const Register thread = NOT_LP64(rax) LP64_ONLY(r15_thread);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1773
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1774 Address queue_index(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1775 PtrQueue::byte_offset_of_index()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1776 Address buffer(thread, in_bytes(JavaThread::dirty_card_queue_offset() +
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1777 PtrQueue::byte_offset_of_buf()));
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1778
362
apetrusenko
parents: 304 342
diff changeset
1779 __ push(rax);
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1780 __ push(rcx);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1781
362
apetrusenko
parents: 304 342
diff changeset
1782 NOT_LP64(__ get_thread(thread);)
apetrusenko
parents: 304 342
diff changeset
1783 ExternalAddress cardtable((address)ct->byte_map_base);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1784 assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1785
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1786 const Register card_addr = rcx;
362
apetrusenko
parents: 304 342
diff changeset
1787 #ifdef _LP64
apetrusenko
parents: 304 342
diff changeset
1788 const Register tmp = rscratch1;
apetrusenko
parents: 304 342
diff changeset
1789 f.load_argument(0, card_addr);
apetrusenko
parents: 304 342
diff changeset
1790 __ shrq(card_addr, CardTableModRefBS::card_shift);
apetrusenko
parents: 304 342
diff changeset
1791 __ lea(tmp, cardtable);
apetrusenko
parents: 304 342
diff changeset
1792 // get the address of the card
apetrusenko
parents: 304 342
diff changeset
1793 __ addq(card_addr, tmp);
apetrusenko
parents: 304 342
diff changeset
1794 #else
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1795 const Register card_index = rcx;
362
apetrusenko
parents: 304 342
diff changeset
1796 f.load_argument(0, card_index);
apetrusenko
parents: 304 342
diff changeset
1797 __ shrl(card_index, CardTableModRefBS::card_shift);
apetrusenko
parents: 304 342
diff changeset
1798
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1799 Address index(noreg, card_index, Address::times_1);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1800 __ leal(card_addr, __ as_Address(ArrayAddress(cardtable, index)));
362
apetrusenko
parents: 304 342
diff changeset
1801 #endif
apetrusenko
parents: 304 342
diff changeset
1802
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1803 __ cmpb(Address(card_addr, 0), 0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1804 __ jcc(Assembler::equal, done);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1805
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1806 // storing region crossing non-NULL, card is clean.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1807 // dirty card and log.
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1808
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1809 __ movb(Address(card_addr, 0), 0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1810
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1811 __ cmpl(queue_index, 0);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1812 __ jcc(Assembler::equal, runtime);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1813 __ subl(queue_index, wordSize);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1814
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1815 const Register buffer_addr = rbx;
362
apetrusenko
parents: 304 342
diff changeset
1816 __ push(rbx);
apetrusenko
parents: 304 342
diff changeset
1817
apetrusenko
parents: 304 342
diff changeset
1818 __ movptr(buffer_addr, buffer);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1819
362
apetrusenko
parents: 304 342
diff changeset
1820 #ifdef _LP64
apetrusenko
parents: 304 342
diff changeset
1821 __ movslq(rscratch1, queue_index);
apetrusenko
parents: 304 342
diff changeset
1822 __ addptr(buffer_addr, rscratch1);
apetrusenko
parents: 304 342
diff changeset
1823 #else
apetrusenko
parents: 304 342
diff changeset
1824 __ addptr(buffer_addr, queue_index);
apetrusenko
parents: 304 342
diff changeset
1825 #endif
apetrusenko
parents: 304 342
diff changeset
1826 __ movptr(Address(buffer_addr, 0), card_addr);
apetrusenko
parents: 304 342
diff changeset
1827
apetrusenko
parents: 304 342
diff changeset
1828 __ pop(rbx);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1829 __ jmp(done);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1830
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1831 __ bind(runtime);
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1832 __ push(rdx);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1833 #ifdef _LP64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1834 __ push(r8);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1835 __ push(r9);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1836 __ push(r10);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1837 __ push(r11);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1838 # ifndef _WIN64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1839 __ push(rdi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1840 __ push(rsi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1841 # endif
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1842 #endif
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1843 __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), card_addr, thread);
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1844 #ifdef _LP64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1845 # ifndef _WIN64
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1846 __ pop(rsi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1847 __ pop(rdi);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1848 # endif
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1849 __ pop(r11);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1850 __ pop(r10);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1851 __ pop(r9);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1852 __ pop(r8);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1853 #endif
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1854 __ pop(rdx);
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1855 __ bind(done);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1856
1572
87fc6aca31ab 6955349: C1: Make G1 barriers work with x64
iveresov
parents: 1564
diff changeset
1857 __ pop(rcx);
362
apetrusenko
parents: 304 342
diff changeset
1858 __ pop(rax);
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1859
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1860 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1861 break;
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
1862 #endif // !SERIALGC
4976
8f01f899bccd More GRAAL #ifdef; ignore graal directory on windows for client/server configuration.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4970
diff changeset
1863 #ifdef GRAAL
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
1864 case graal_unwind_exception_call_id: {
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1865 // remove the frame from the stack
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1866 __ movptr(rsp, rbp);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1867 __ pop(rbp);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1868 // exception_oop is passed using ordinary java calling conventions
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1869 __ movptr(rax, j_rarg0);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1870
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1871 Label nonNullExceptionOop;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1872 __ testptr(rax, rax);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1873 __ jcc(Assembler::notZero, nonNullExceptionOop);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
1874 {
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1875 __ enter();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1876 oop_maps = new OopMapSet();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1877 OopMap* oop_map = save_live_registers(sasm, 0);
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
1878 int call_offset = __ call_RT(rax, noreg, (address)graal_create_null_exception, 0);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1879 oop_maps->add_gc_map(call_offset, oop_map);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1880 __ leave();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1881 }
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1882 __ bind(nonNullExceptionOop);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
1883
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1884 __ set_info("unwind_exception", dont_gc_arguments);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1885 // note: no stubframe since we are about to leave the current
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1886 // activation and we are calling a leaf VM function only.
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1887 generate_unwind_exception(sasm);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1888 __ should_not_reach_here();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1889 break;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1890 }
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
1891
6674
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1892 case graal_OSR_migration_end_id: {
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1893 __ enter();
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1894 save_live_registers(sasm, 0);
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1895 __ movptr(c_rarg0, j_rarg0);
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1896 __ call(RuntimeAddress(CAST_FROM_FN_PTR(address, SharedRuntime::OSR_migration_end)));
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1897 restore_live_registers(sasm);
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1898 __ leave();
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1899 __ ret(0);
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1900 break;
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1901 }
fd71ca8c5f88 VM infrstructure for OnStackReplacement
Lukas Stadler <lukas.stadler@jku.at>
parents: 6521
diff changeset
1902
3558
bc95d122df79 added runtime call to supply info upon deoptimization
Lukas Stadler <lukas.stadler@jku.at>
parents: 3538
diff changeset
1903 case graal_set_deopt_info_id: {
bc95d122df79 added runtime call to supply info upon deoptimization
Lukas Stadler <lukas.stadler@jku.at>
parents: 3538
diff changeset
1904 __ movptr(Address(r15_thread, JavaThread::graal_deopt_info_offset()), rscratch1);
bc95d122df79 added runtime call to supply info upon deoptimization
Lukas Stadler <lukas.stadler@jku.at>
parents: 3538
diff changeset
1905 __ ret(0);
bc95d122df79 added runtime call to supply info upon deoptimization
Lukas Stadler <lukas.stadler@jku.at>
parents: 3538
diff changeset
1906 break;
bc95d122df79 added runtime call to supply info upon deoptimization
Lukas Stadler <lukas.stadler@jku.at>
parents: 3538
diff changeset
1907 }
bc95d122df79 added runtime call to supply info upon deoptimization
Lukas Stadler <lukas.stadler@jku.at>
parents: 3538
diff changeset
1908
3538
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1909 case graal_create_null_pointer_exception_id: {
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1910 __ enter();
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1911 oop_maps = new OopMapSet();
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1912 OopMap* oop_map = save_live_registers(sasm, 0);
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1913 int call_offset = __ call_RT(rax, noreg, (address)graal_create_null_exception, 0);
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1914 oop_maps->add_gc_map(call_offset, oop_map);
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1915 __ leave();
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1916 __ ret(0);
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1917 break;
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1918 }
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1919
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1920 case graal_create_out_of_bounds_exception_id: {
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1921 __ enter();
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1922 oop_maps = new OopMapSet();
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1923 OopMap* oop_map = save_live_registers(sasm, 0);
5240
ec177db4a412 fixed incorrect register arg in graal_create_out_of_bounds_exception stub
Doug Simon <doug.simon@oracle.com>
parents: 5124
diff changeset
1924 int call_offset = __ call_RT(rax, noreg, (address)graal_create_out_of_bounds_exception, j_rarg0);
3538
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1925 oop_maps->add_gc_map(call_offset, oop_map);
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1926 __ leave();
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1927 __ ret(0);
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1928 break;
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1929 }
e4616e3d207b support for new CiRuntimeCalls CreateNullPointerException and CreateOutOfBoundsException
Lukas Stadler <lukas.stadler@jku.at>
parents: 3509
diff changeset
1930
6453
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1931 case graal_vm_error_id: {
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1932 __ enter();
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1933 oop_maps = new OopMapSet();
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1934 OopMap* oop_map = save_live_registers(sasm, 0);
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1935 int call_offset = __ call_RT(noreg, noreg, (address)graal_vm_error, j_rarg0, j_rarg1, j_rarg2);
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1936 oop_maps->add_gc_map(call_offset, oop_map);
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1937 restore_live_registers(sasm);
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1938 __ leave();
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1939 __ ret(0);
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1940 break;
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1941 }
3bba61323b38 added VMErrorNode intrinsic to support handling fatal errors in snippets
Doug Simon <doug.simon@oracle.com>
parents: 6446
diff changeset
1942
6446
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1943 case graal_log_printf_id: {
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1944 __ enter();
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1945 oop_maps = new OopMapSet();
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1946 OopMap* oop_map = save_live_registers(sasm, 0);
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1947 int call_offset = __ call_RT(noreg, noreg, (address)graal_log_printf, j_rarg0, j_rarg1, j_rarg2);
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1948 oop_maps->add_gc_map(call_offset, oop_map);
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1949 restore_live_registers(sasm);
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1950 __ leave();
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1951 __ ret(0);
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1952 break;
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1953 }
c8759f9f9e3c added Log.printf() for more flexibility in debugging snippets
Doug Simon <doug.simon@oracle.com>
parents: 6388
diff changeset
1954
5586
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1955 case graal_log_primitive_id: {
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1956 __ enter();
5593
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1957 oop_maps = new OopMapSet();
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1958 OopMap* oop_map = save_live_registers(sasm, 0);
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1959 int call_offset = __ call_RT(noreg, noreg, (address)graal_log_primitive, j_rarg0, j_rarg1, j_rarg2);
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1960 oop_maps->add_gc_map(call_offset, oop_map);
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1961 restore_live_registers(sasm);
5586
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1962 __ leave();
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1963 __ ret(0);
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1964 break;
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1965 }
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1966
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1967 case graal_log_object_id: {
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1968 __ enter();
5593
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1969 oop_maps = new OopMapSet();
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1970 OopMap* oop_map = save_live_registers(sasm, 0);
6388
6b74f44c5059 added Log.printObject() and Log.printlnObject() for more detailed logging of objects
Doug Simon <doug.simon@oracle.com>
parents: 6275
diff changeset
1971 int call_offset = __ call_RT(noreg, noreg, (address)graal_log_object, j_rarg0, j_rarg1);
5593
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1972 oop_maps->add_gc_map(call_offset, oop_map);
fcb8d2b8dc42 fixed bug in stubs for RuntimeCall.LogObject and RuntimeCall.LogPrimitive: was missing frame management code around runtime call
Doug Simon <doug.simon@oracle.com>
parents: 5586
diff changeset
1973 restore_live_registers(sasm);
5586
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1974 __ leave();
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1975 __ ret(0);
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1976 break;
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1977 }
b0d06c58200c added missing stub implementation for RuntimeCall.LogObject and RuntimeCall.LogPrimitive
Doug Simon <doug.simon@oracle.com>
parents: 5573
diff changeset
1978
5624
7d25723b7699 added oop verification to NewInstanceSnippets when -XX:+VerifyOops is enabled
Doug Simon <doug.simon@oracle.com>
parents: 5618
diff changeset
1979 case graal_verify_oop_id: {
5665
17639f600cda made graal_verify_oop stub create a frame to improve crash log when it fails
Doug Simon <doug.simon@oracle.com>
parents: 5624
diff changeset
1980 // We use enter & leave so that a better stack trace is produced in the hs_err file
17639f600cda made graal_verify_oop stub create a frame to improve crash log when it fails
Doug Simon <doug.simon@oracle.com>
parents: 5624
diff changeset
1981 __ enter();
5624
7d25723b7699 added oop verification to NewInstanceSnippets when -XX:+VerifyOops is enabled
Doug Simon <doug.simon@oracle.com>
parents: 5618
diff changeset
1982 __ verify_oop(r13, "graal verify oop");
5665
17639f600cda made graal_verify_oop stub create a frame to improve crash log when it fails
Doug Simon <doug.simon@oracle.com>
parents: 5624
diff changeset
1983 __ leave();
1449
8cfe3537a0d3 Pointer verification stub. Two loose oop fixes in C1X C++ part. Logging which methods have been compiled.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents: 1434
diff changeset
1984 __ ret(0);
8cfe3537a0d3 Pointer verification stub. Two loose oop fixes in C1X C++ part. Logging which methods have been compiled.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents: 1434
diff changeset
1985 break;
8cfe3537a0d3 Pointer verification stub. Two loose oop fixes in C1X C++ part. Logging which methods have been compiled.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents: 1434
diff changeset
1986 }
8cfe3537a0d3 Pointer verification stub. Two loose oop fixes in C1X C++ part. Logging which methods have been compiled.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents: 1434
diff changeset
1987
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
1988 case graal_arithmetic_frem_id: {
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1989 __ subptr(rsp, 8);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1990 __ movflt(Address(rsp, 0), xmm1);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1991 __ fld_s(Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1992 __ movflt(Address(rsp, 0), xmm0);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1993 __ fld_s(Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1994 Label L;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1995 __ bind(L);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1996 __ fprem();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1997 __ fwait();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1998 __ fnstsw_ax();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
1999 __ testl(rax, 0x400);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2000 __ jcc(Assembler::notZero, L);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2001 __ fxch(1);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2002 __ fpop();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2003 __ fstp_s(Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2004 __ movflt(xmm0, Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2005 __ addptr(rsp, 8);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2006 __ ret(0);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2007 break;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2008 }
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
2009 case graal_arithmetic_drem_id: {
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2010 __ subptr(rsp, 8);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2011 __ movdbl(Address(rsp, 0), xmm1);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2012 __ fld_d(Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2013 __ movdbl(Address(rsp, 0), xmm0);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2014 __ fld_d(Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2015 Label L;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2016 __ bind(L);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2017 __ fprem();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2018 __ fwait();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2019 __ fnstsw_ax();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2020 __ testl(rax, 0x400);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2021 __ jcc(Assembler::notZero, L);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2022 __ fxch(1);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2023 __ fpop();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2024 __ fstp_d(Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2025 __ movdbl(xmm0, Address(rsp, 0));
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2026 __ addptr(rsp, 8);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2027 __ ret(0);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2028 break;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2029 }
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
2030 case graal_monitorenter_id: {
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2031 Label slow_case;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2032
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2033 Register obj = j_rarg0;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2034 Register lock = j_rarg1;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2035
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2036 Register scratch1 = rax;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2037 Register scratch2 = rbx;
1942
00bc9eaf0e24 Support for -XX:+UseFastLocking flag. Fixed monitor enter XIR template for correct debug info at the runtime call.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents: 1930
diff changeset
2038 assert_different_registers(obj, lock, scratch1, scratch2);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2039
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2040 // copied from LIR_Assembler::emit_lock
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2041 if (UseFastLocking) {
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2042 assert(BasicLock::displaced_header_offset_in_bytes() == 0, "lock_reg must point to the displaced header");
3714
b648304ba4ff Change Graal monitor enter and exit from BasicObjectLock to BasicLock
Christian Wimmer <christian.wimmer@oracle.com>
parents: 3705
diff changeset
2043 __ lock_object(scratch1, obj, lock, scratch2, slow_case, false);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2044 __ ret(0);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2045 }
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2046
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2047 __ bind(slow_case);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2048 {
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
2049 StubFrame f(sasm, "graal_monitorenter", dont_gc_arguments);
3714
b648304ba4ff Change Graal monitor enter and exit from BasicObjectLock to BasicLock
Christian Wimmer <christian.wimmer@oracle.com>
parents: 3705
diff changeset
2050 OopMap* map = save_live_registers(sasm, 2, save_fpu_registers);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2051
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2052 // Called with store_parameter and not C abi
3714
b648304ba4ff Change Graal monitor enter and exit from BasicObjectLock to BasicLock
Christian Wimmer <christian.wimmer@oracle.com>
parents: 3705
diff changeset
2053 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, graal_monitorenter), obj, lock);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2054
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2055 oop_maps = new OopMapSet();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2056 oop_maps->add_gc_map(call_offset, map);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2057 restore_live_registers(sasm, save_fpu_registers);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2058 }
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2059 __ ret(0);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2060 break;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2061 }
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
2062 case graal_monitorexit_id: {
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2063 Label slow_case;
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2064
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2065 Register obj = j_rarg0;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2066 Register lock = j_rarg1;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2067
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2068 // needed in rax later on...
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2069 Register lock2 = rax;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2070 __ mov(lock2, lock);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2071 Register scratch1 = rbx;
1942
00bc9eaf0e24 Support for -XX:+UseFastLocking flag. Fixed monitor enter XIR template for correct debug info at the runtime call.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents: 1930
diff changeset
2072 assert_different_registers(obj, lock, scratch1, lock2);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2073
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2074 // copied from LIR_Assembler::emit_lock
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2075 if (UseFastLocking) {
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2076 assert(BasicLock::displaced_header_offset_in_bytes() == 0, "lock_reg must point to the displaced header");
3714
b648304ba4ff Change Graal monitor enter and exit from BasicObjectLock to BasicLock
Christian Wimmer <christian.wimmer@oracle.com>
parents: 3705
diff changeset
2077 __ unlock_object(scratch1, obj, lock2, slow_case, false);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2078 __ ret(0);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2079 }
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2080
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2081 __ bind(slow_case);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2082 {
2891
75a99b4f1c98 Rebranded C++ part from C1X to Graal.
Thomas Wuerthinger <thomas@wuerthinger.net>
parents: 2662
diff changeset
2083 StubFrame f(sasm, "graal_monitorexit", dont_gc_arguments);
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2084 OopMap* map = save_live_registers(sasm, 2, save_fpu_registers);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2085
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2086 // note: really a leaf routine but must setup last java sp
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2087 // => use call_RT for now (speed can be improved by
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2088 // doing last java sp setup manually)
3714
b648304ba4ff Change Graal monitor enter and exit from BasicObjectLock to BasicLock
Christian Wimmer <christian.wimmer@oracle.com>
parents: 3705
diff changeset
2089 int call_offset = __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, graal_monitorexit), obj, lock);
1429
abc670a709dc * -XX:TraceC1X=0...5 controls the native c1x tracing
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1423
diff changeset
2090
1434
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2091 oop_maps = new OopMapSet();
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2092 oop_maps->add_gc_map(call_offset, map);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2093 restore_live_registers(sasm, save_fpu_registers);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2094 }
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2095 __ ret(0);
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2096 break;
72cfb36c6bb2 * enabled all jtt tests
Lukas Stadler <lukas.stadler@oracle.com>
parents: 1429
diff changeset
2097 }
4976
8f01f899bccd More GRAAL #ifdef; ignore graal directory on windows for client/server configuration.
Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
parents: 4970
diff changeset
2098 #endif
342
37f87013dfd8 6711316: Open source the Garbage-First garbage collector
ysr
parents: 0
diff changeset
2099
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2100 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
2101 { StubFrame f(sasm, "unimplemented entry", dont_gc_arguments);
304
dc7f315e41f7 5108146: Merge i486 and amd64 cpu directories
never
parents: 0
diff changeset
2102 __ movptr(rax, (int)id);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
2103 __ call_RT(noreg, noreg, CAST_FROM_FN_PTR(address, unimplemented_entry), rax);
a61af66fc99e Initial load
duke
parents:
diff changeset
2104 __ should_not_reach_here();
a61af66fc99e Initial load
duke
parents:
diff changeset
2105 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2106 break;
a61af66fc99e Initial load
duke
parents:
diff changeset
2107 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2108 return oop_maps;
a61af66fc99e Initial load
duke
parents:
diff changeset
2109 }
a61af66fc99e Initial load
duke
parents:
diff changeset
2110
a61af66fc99e Initial load
duke
parents:
diff changeset
2111 #undef __
1681
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1579
diff changeset
2112
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1579
diff changeset
2113 const char *Runtime1::pd_name_for_address(address entry) {
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1579
diff changeset
2114 return "<unknown function>";
126ea7725993 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 1579
diff changeset
2115 }