1 /*
2 * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2009, 2010 Red Hat, Inc.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26 #include "incls/_precompiled.incl"
27 #include "incls/_sharkNativeWrapper.cpp.incl"
28
29 using namespace llvm;
30
31 void SharkNativeWrapper::initialize(const char *name) {
32 // Create the function
33 _function = Function::Create(
34 SharkType::entry_point_type(),
35 GlobalVariable::InternalLinkage,
36 name);
37
38 // Get our arguments
39 Function::arg_iterator ai = function()->arg_begin();
40 Argument *method = ai++;
41 method->setName("method");
42 Argument *base_pc = ai++;
43 base_pc->setName("base_pc");
44 code_buffer()->set_base_pc(base_pc);
45 Argument *thread = ai++;
46 thread->setName("thread");
47 set_thread(thread);
48
49 // Create and push our stack frame
50 builder()->SetInsertPoint(CreateBlock());
51 _stack = SharkStack::CreateBuildAndPushFrame(this, method);
52 NOT_PRODUCT(method = NULL);
53
54 // Create the oopmap. We use the one oopmap for every call site in
55 // the wrapper, which results in the odd mild inefficiency but is a
56 // damn sight easier to code.
57 OopMap *oopmap = new OopMap(
58 SharkStack::oopmap_slot_munge(stack()->oopmap_frame_size()),
59 SharkStack::oopmap_slot_munge(arg_size()));
60 oopmap->set_oop(SharkStack::slot2reg(stack()->method_slot_offset()));
61
62 // Set up the oop_tmp slot if required:
63 // - For static methods we use it to handlize the class argument
64 // for the call, and to protect the same during slow path locks
65 // (if synchronized).
66 // - For methods returning oops, we use it to protect the return
67 // value across safepoints or slow path unlocking.
68 if (is_static() || is_returning_oop()) {
69 _oop_tmp_slot = stack()->slot_addr(
70 stack()->oop_tmp_slot_offset(),
71 SharkType::oop_type(),
72 "oop_tmp_slot");
73
74 oopmap->set_oop(SharkStack::slot2reg(stack()->oop_tmp_slot_offset()));
75 }
76
77 // Set up the monitor slot, for synchronized methods
78 if (is_synchronized()) {
79 Unimplemented();
80 _lock_slot_offset = 23;
81 }
82
83 // Start building the argument list
84 std::vector<const Type*> param_types;
85 std::vector<Value*> param_values;
86 const PointerType *box_type = PointerType::getUnqual(SharkType::oop_type());
87
88 // First argument is the JNIEnv
89 param_types.push_back(SharkType::jniEnv_type());
90 param_values.push_back(
91 builder()->CreateAddressOfStructEntry(
92 thread,
93 JavaThread::jni_environment_offset(),
94 SharkType::jniEnv_type(),
95 "jni_environment"));
96
97 // For static methods, the second argument is the class
98 if (is_static()) {
99 builder()->CreateStore(
100 builder()->CreateInlineOop(
101 JNIHandles::make_local(
102 target()->method_holder()->klass_part()->java_mirror())),
103 oop_tmp_slot());
104
105 param_types.push_back(box_type);
106 param_values.push_back(oop_tmp_slot());
107
108 _receiver_slot_offset = stack()->oop_tmp_slot_offset();
109 }
110 else if (is_returning_oop()) {
111 // The oop_tmp slot is registered in the oopmap,
112 // so we need to clear it. This is one of the
113 // mild inefficiencies I mentioned earlier.
114 builder()->CreateStore(LLVMValue::null(), oop_tmp_slot());
115 }
116
117 // Parse the arguments
118 for (int i = 0; i < arg_size(); i++) {
119 int slot_offset = stack()->locals_slots_offset() + arg_size() - 1 - i;
120 int adjusted_offset = slot_offset;
121 BasicBlock *null, *not_null, *merge;
122 Value *box;
123 PHINode *phi;
124
125 switch (arg_type(i)) {
126 case T_VOID:
127 break;
128
129 case T_OBJECT:
130 case T_ARRAY:
131 null = CreateBlock("null");
132 not_null = CreateBlock("not_null");
133 merge = CreateBlock("merge");
134
135 box = stack()->slot_addr(slot_offset, SharkType::oop_type());
136 builder()->CreateCondBr(
137 builder()->CreateICmp(
138 ICmpInst::ICMP_EQ,
139 builder()->CreateLoad(box),
140 LLVMValue::null()),
141 null, not_null);
142
143 builder()->SetInsertPoint(null);
144 builder()->CreateBr(merge);
145
146 builder()->SetInsertPoint(not_null);
147 builder()->CreateBr(merge);
148
149 builder()->SetInsertPoint(merge);
150 phi = builder()->CreatePHI(box_type, "boxed_object");
151 phi->addIncoming(ConstantPointerNull::get(box_type), null);
152 phi->addIncoming(box, not_null);
153 box = phi;
154
155 param_types.push_back(box_type);
156 param_values.push_back(box);
157
158 oopmap->set_oop(SharkStack::slot2reg(slot_offset));
159
160 if (i == 0 && !is_static())
161 _receiver_slot_offset = slot_offset;
162
163 break;
164
165 case T_LONG:
166 case T_DOUBLE:
167 adjusted_offset--;
168 // fall through
169
170 default:
171 const Type *param_type = SharkType::to_stackType(arg_type(i));
172
173 param_types.push_back(param_type);
174 param_values.push_back(
175 builder()->CreateLoad(stack()->slot_addr(adjusted_offset, param_type)));
176 }
177 }
178
179 // The oopmap is now complete, and everything is written
180 // into the frame except the PC.
181 int pc_offset = code_buffer()->create_unique_offset();
182
183 _oop_maps = new OopMapSet();
184 oop_maps()->add_gc_map(pc_offset, oopmap);
185
186 builder()->CreateStore(
187 builder()->code_buffer_address(pc_offset),
188 stack()->slot_addr(stack()->pc_slot_offset()));
189
190 // Set up the Java frame anchor
191 stack()->CreateSetLastJavaFrame();
192
193 // Lock if necessary
194 if (is_synchronized())
195 Unimplemented();
196
197 // Change the thread state to _thread_in_native
198 CreateSetThreadState(_thread_in_native);
199
200 // Make the call
201 BasicType result_type = target()->result_type();
202 const Type* return_type;
203 if (result_type == T_VOID)
204 return_type = SharkType::void_type();
205 else if (is_returning_oop())
206 return_type = box_type;
207 else
208 return_type = SharkType::to_arrayType(result_type);
209 Value* native_function = builder()->CreateIntToPtr(
210 LLVMValue::intptr_constant((intptr_t) target()->native_function()),
211 PointerType::getUnqual(
212 FunctionType::get(return_type, param_types, false)));
213 Value *result = builder()->CreateCall(
214 native_function, param_values.begin(), param_values.end());
215
216 // Start the transition back to _thread_in_Java
217 CreateSetThreadState(_thread_in_native_trans);
218
219 // Make sure new state is visible in the GC thread
220 if (os::is_MP()) {
221 if (UseMembar)
222 builder()->CreateMemoryBarrier(SharkBuilder::BARRIER_STORELOAD);
223 else
224 CreateWriteMemorySerializePage();
225 }
226
227 // Handle safepoint operations, pending suspend requests,
228 // and pending asynchronous exceptions.
229 BasicBlock *check_thread = CreateBlock("check_thread");
230 BasicBlock *do_safepoint = CreateBlock("do_safepoint");
231 BasicBlock *safepointed = CreateBlock("safepointed");
232
233 Value *global_state = builder()->CreateLoad(
234 builder()->CreateIntToPtr(
235 LLVMValue::intptr_constant(
236 (intptr_t) SafepointSynchronize::address_of_state()),
237 PointerType::getUnqual(SharkType::jint_type())),
238 "global_state");
239
240 builder()->CreateCondBr(
241 builder()->CreateICmpNE(
242 global_state,
243 LLVMValue::jint_constant(SafepointSynchronize::_not_synchronized)),
244 do_safepoint, check_thread);
245
246 builder()->SetInsertPoint(check_thread);
247 Value *thread_state = builder()->CreateValueOfStructEntry(
248 thread,
249 JavaThread::suspend_flags_offset(),
250 SharkType::jint_type(),
251 "thread_state");
252
253 builder()->CreateCondBr(
254 builder()->CreateICmpNE(
255 thread_state,
256 LLVMValue::jint_constant(0)),
257 do_safepoint, safepointed);
258
259 builder()->SetInsertPoint(do_safepoint);
260 builder()->CreateCall(
261 builder()->check_special_condition_for_native_trans(), thread);
262 builder()->CreateBr(safepointed);
263
264 // Finally we can change the thread state to _thread_in_Java
265 builder()->SetInsertPoint(safepointed);
266 CreateSetThreadState(_thread_in_Java);
267
268 // Clear the frame anchor
269 stack()->CreateResetLastJavaFrame();
270
271 // If there is a pending exception then we can just unwind and
272 // return. It seems totally wrong that unlocking is skipped here
273 // but apparently the template interpreter does this so we do too.
274 BasicBlock *exception = CreateBlock("exception");
275 BasicBlock *no_exception = CreateBlock("no_exception");
276
277 builder()->CreateCondBr(
278 builder()->CreateICmpEQ(
279 CreateLoadPendingException(),
280 LLVMValue::null()),
281 no_exception, exception);
282
283 builder()->SetInsertPoint(exception);
284 CreateResetHandleBlock();
285 stack()->CreatePopFrame(0);
286 builder()->CreateRet(LLVMValue::jint_constant(0));
287
288 builder()->SetInsertPoint(no_exception);
289
290 // If the result was an oop then unbox it before
291 // releasing the handle it might be protected by
292 if (is_returning_oop()) {
293 BasicBlock *null = builder()->GetInsertBlock();
294 BasicBlock *not_null = CreateBlock("not_null");
295 BasicBlock *merge = CreateBlock("merge");
296
297 builder()->CreateCondBr(
298 builder()->CreateICmpNE(result, ConstantPointerNull::get(box_type)),
299 not_null, merge);
300
301 builder()->SetInsertPoint(not_null);
302 Value *unboxed_result = builder()->CreateLoad(result);
303 builder()->CreateBr(merge);
304
305 builder()->SetInsertPoint(merge);
306 PHINode *phi = builder()->CreatePHI(SharkType::oop_type(), "result");
307 phi->addIncoming(LLVMValue::null(), null);
308 phi->addIncoming(unboxed_result, not_null);
309 result = phi;
310 }
311
312 // Reset handle block
313 CreateResetHandleBlock();
314
315 // Unlock if necessary.
316 if (is_synchronized())
317 Unimplemented();
318
319 // Unwind and return
320 Value *result_addr = stack()->CreatePopFrame(type2size[result_type]);
321 if (result_type != T_VOID) {
322 bool needs_cast = false;
323 bool is_signed = false;
324 switch (result_type) {
325 case T_BOOLEAN:
326 result = builder()->CreateICmpNE(result, LLVMValue::jbyte_constant(0));
327 needs_cast = true;
328 break;
329
330 case T_CHAR:
331 needs_cast = true;
332 break;
333
334 case T_BYTE:
335 case T_SHORT:
336 needs_cast = true;
337 is_signed = true;
338 break;
339 }
340 if (needs_cast) {
341 result = builder()->CreateIntCast(
342 result, SharkType::to_stackType(result_type), is_signed);
343 }
344
345 builder()->CreateStore(
346 result,
347 builder()->CreateIntToPtr(
348 result_addr,
349 PointerType::getUnqual(SharkType::to_stackType(result_type))));
350 }
351 builder()->CreateRet(LLVMValue::jint_constant(0));
352 }