|
1 /* |
|
2 * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved. |
|
3 * Copyright 2008, 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/_sharkBuilder.cpp.incl" |
|
28 |
|
29 using namespace llvm; |
|
30 |
|
31 SharkBuilder::SharkBuilder(SharkCodeBuffer* code_buffer) |
|
32 : IRBuilder<>(SharkContext::current()), |
|
33 _code_buffer(code_buffer) { |
|
34 } |
|
35 |
|
36 // Helpers for accessing structures |
|
37 Value* SharkBuilder::CreateAddressOfStructEntry(Value* base, |
|
38 ByteSize offset, |
|
39 const Type* type, |
|
40 const char* name) { |
|
41 return CreateBitCast(CreateStructGEP(base, in_bytes(offset)), type, name); |
|
42 } |
|
43 |
|
44 LoadInst* SharkBuilder::CreateValueOfStructEntry(Value* base, |
|
45 ByteSize offset, |
|
46 const Type* type, |
|
47 const char* name) { |
|
48 return CreateLoad( |
|
49 CreateAddressOfStructEntry( |
|
50 base, offset, PointerType::getUnqual(type)), |
|
51 name); |
|
52 } |
|
53 |
|
54 // Helpers for accessing arrays |
|
55 |
|
56 LoadInst* SharkBuilder::CreateArrayLength(Value* arrayoop) { |
|
57 return CreateValueOfStructEntry( |
|
58 arrayoop, in_ByteSize(arrayOopDesc::length_offset_in_bytes()), |
|
59 SharkType::jint_type(), "length"); |
|
60 } |
|
61 |
|
62 Value* SharkBuilder::CreateArrayAddress(Value* arrayoop, |
|
63 const Type* element_type, |
|
64 int element_bytes, |
|
65 ByteSize base_offset, |
|
66 Value* index, |
|
67 const char* name) { |
|
68 Value* offset = CreateIntCast(index, SharkType::intptr_type(), false); |
|
69 if (element_bytes != 1) |
|
70 offset = CreateShl( |
|
71 offset, |
|
72 LLVMValue::intptr_constant(exact_log2(element_bytes))); |
|
73 offset = CreateAdd( |
|
74 LLVMValue::intptr_constant(in_bytes(base_offset)), offset); |
|
75 |
|
76 return CreateIntToPtr( |
|
77 CreateAdd(CreatePtrToInt(arrayoop, SharkType::intptr_type()), offset), |
|
78 PointerType::getUnqual(element_type), |
|
79 name); |
|
80 } |
|
81 |
|
82 Value* SharkBuilder::CreateArrayAddress(Value* arrayoop, |
|
83 BasicType basic_type, |
|
84 ByteSize base_offset, |
|
85 Value* index, |
|
86 const char* name) { |
|
87 return CreateArrayAddress( |
|
88 arrayoop, |
|
89 SharkType::to_arrayType(basic_type), |
|
90 type2aelembytes(basic_type), |
|
91 base_offset, index, name); |
|
92 } |
|
93 |
|
94 Value* SharkBuilder::CreateArrayAddress(Value* arrayoop, |
|
95 BasicType basic_type, |
|
96 Value* index, |
|
97 const char* name) { |
|
98 return CreateArrayAddress( |
|
99 arrayoop, basic_type, |
|
100 in_ByteSize(arrayOopDesc::base_offset_in_bytes(basic_type)), |
|
101 index, name); |
|
102 } |
|
103 |
|
104 // Helpers for creating intrinsics and external functions. |
|
105 |
|
106 const Type* SharkBuilder::make_type(char type, bool void_ok) { |
|
107 switch (type) { |
|
108 // Primitive types |
|
109 case 'c': |
|
110 return SharkType::jbyte_type(); |
|
111 case 'i': |
|
112 return SharkType::jint_type(); |
|
113 case 'l': |
|
114 return SharkType::jlong_type(); |
|
115 case 'x': |
|
116 return SharkType::intptr_type(); |
|
117 case 'f': |
|
118 return SharkType::jfloat_type(); |
|
119 case 'd': |
|
120 return SharkType::jdouble_type(); |
|
121 |
|
122 // Pointers to primitive types |
|
123 case 'C': |
|
124 case 'I': |
|
125 case 'L': |
|
126 case 'X': |
|
127 case 'F': |
|
128 case 'D': |
|
129 return PointerType::getUnqual(make_type(tolower(type), false)); |
|
130 |
|
131 // VM objects |
|
132 case 'T': |
|
133 return SharkType::thread_type(); |
|
134 case 'M': |
|
135 return PointerType::getUnqual(SharkType::monitor_type()); |
|
136 case 'O': |
|
137 return SharkType::oop_type(); |
|
138 |
|
139 // Miscellaneous |
|
140 case 'v': |
|
141 assert(void_ok, "should be"); |
|
142 return SharkType::void_type(); |
|
143 case '1': |
|
144 return SharkType::bit_type(); |
|
145 |
|
146 default: |
|
147 ShouldNotReachHere(); |
|
148 } |
|
149 } |
|
150 |
|
151 const FunctionType* SharkBuilder::make_ftype(const char* params, |
|
152 const char* ret) { |
|
153 std::vector<const Type*> param_types; |
|
154 for (const char* c = params; *c; c++) |
|
155 param_types.push_back(make_type(*c, false)); |
|
156 |
|
157 assert(strlen(ret) == 1, "should be"); |
|
158 const Type *return_type = make_type(*ret, true); |
|
159 |
|
160 return FunctionType::get(return_type, param_types, false); |
|
161 } |
|
162 |
|
163 // Create an object representing an intrinsic or external function by |
|
164 // referencing the symbol by name. This is the LLVM-style approach, |
|
165 // but it cannot be used on functions within libjvm.so its symbols |
|
166 // are not exported. Note that you cannot make this work simply by |
|
167 // exporting the symbols, as some symbols have the same names as |
|
168 // symbols in the standard libraries (eg, atan2, fabs) and would |
|
169 // obscure them were they visible. |
|
170 Value* SharkBuilder::make_function(const char* name, |
|
171 const char* params, |
|
172 const char* ret) { |
|
173 return SharkContext::current().get_external(name, make_ftype(params, ret)); |
|
174 } |
|
175 |
|
176 // Create an object representing an external function by inlining a |
|
177 // function pointer in the code. This is not the LLVM way, but it's |
|
178 // the only way to access functions in libjvm.so and functions like |
|
179 // __kernel_dmb on ARM which is accessed via an absolute address. |
|
180 Value* SharkBuilder::make_function(address func, |
|
181 const char* params, |
|
182 const char* ret) { |
|
183 return CreateIntToPtr( |
|
184 LLVMValue::intptr_constant((intptr_t) func), |
|
185 PointerType::getUnqual(make_ftype(params, ret))); |
|
186 } |
|
187 |
|
188 // VM calls |
|
189 |
|
190 Value* SharkBuilder::find_exception_handler() { |
|
191 return make_function( |
|
192 (address) SharkRuntime::find_exception_handler, "TIi", "i"); |
|
193 } |
|
194 |
|
195 Value* SharkBuilder::monitorenter() { |
|
196 return make_function((address) SharkRuntime::monitorenter, "TM", "v"); |
|
197 } |
|
198 |
|
199 Value* SharkBuilder::monitorexit() { |
|
200 return make_function((address) SharkRuntime::monitorexit, "TM", "v"); |
|
201 } |
|
202 |
|
203 Value* SharkBuilder::new_instance() { |
|
204 return make_function((address) SharkRuntime::new_instance, "Ti", "v"); |
|
205 } |
|
206 |
|
207 Value* SharkBuilder::newarray() { |
|
208 return make_function((address) SharkRuntime::newarray, "Tii", "v"); |
|
209 } |
|
210 |
|
211 Value* SharkBuilder::anewarray() { |
|
212 return make_function((address) SharkRuntime::anewarray, "Tii", "v"); |
|
213 } |
|
214 |
|
215 Value* SharkBuilder::multianewarray() { |
|
216 return make_function((address) SharkRuntime::multianewarray, "TiiI", "v"); |
|
217 } |
|
218 |
|
219 Value* SharkBuilder::register_finalizer() { |
|
220 return make_function((address) SharkRuntime::register_finalizer, "TO", "v"); |
|
221 } |
|
222 |
|
223 Value* SharkBuilder::safepoint() { |
|
224 return make_function((address) SafepointSynchronize::block, "T", "v"); |
|
225 } |
|
226 |
|
227 Value* SharkBuilder::throw_ArithmeticException() { |
|
228 return make_function( |
|
229 (address) SharkRuntime::throw_ArithmeticException, "TCi", "v"); |
|
230 } |
|
231 |
|
232 Value* SharkBuilder::throw_ArrayIndexOutOfBoundsException() { |
|
233 return make_function( |
|
234 (address) SharkRuntime::throw_ArrayIndexOutOfBoundsException, "TCii", "v"); |
|
235 } |
|
236 |
|
237 Value* SharkBuilder::throw_ClassCastException() { |
|
238 return make_function( |
|
239 (address) SharkRuntime::throw_ClassCastException, "TCi", "v"); |
|
240 } |
|
241 |
|
242 Value* SharkBuilder::throw_NullPointerException() { |
|
243 return make_function( |
|
244 (address) SharkRuntime::throw_NullPointerException, "TCi", "v"); |
|
245 } |
|
246 |
|
247 // High-level non-VM calls |
|
248 |
|
249 Value* SharkBuilder::f2i() { |
|
250 return make_function((address) SharedRuntime::f2i, "f", "i"); |
|
251 } |
|
252 |
|
253 Value* SharkBuilder::f2l() { |
|
254 return make_function((address) SharedRuntime::f2l, "f", "l"); |
|
255 } |
|
256 |
|
257 Value* SharkBuilder::d2i() { |
|
258 return make_function((address) SharedRuntime::d2i, "d", "i"); |
|
259 } |
|
260 |
|
261 Value* SharkBuilder::d2l() { |
|
262 return make_function((address) SharedRuntime::d2l, "d", "l"); |
|
263 } |
|
264 |
|
265 Value* SharkBuilder::is_subtype_of() { |
|
266 return make_function((address) SharkRuntime::is_subtype_of, "OO", "c"); |
|
267 } |
|
268 |
|
269 Value* SharkBuilder::current_time_millis() { |
|
270 return make_function((address) os::javaTimeMillis, "", "l"); |
|
271 } |
|
272 |
|
273 Value* SharkBuilder::sin() { |
|
274 return make_function("llvm.sin.f64", "d", "d"); |
|
275 } |
|
276 |
|
277 Value* SharkBuilder::cos() { |
|
278 return make_function("llvm.cos.f64", "d", "d"); |
|
279 } |
|
280 |
|
281 Value* SharkBuilder::tan() { |
|
282 return make_function((address) ::tan, "d", "d"); |
|
283 } |
|
284 |
|
285 Value* SharkBuilder::atan2() { |
|
286 return make_function((address) ::atan2, "dd", "d"); |
|
287 } |
|
288 |
|
289 Value* SharkBuilder::sqrt() { |
|
290 return make_function("llvm.sqrt.f64", "d", "d"); |
|
291 } |
|
292 |
|
293 Value* SharkBuilder::log() { |
|
294 return make_function("llvm.log.f64", "d", "d"); |
|
295 } |
|
296 |
|
297 Value* SharkBuilder::log10() { |
|
298 return make_function("llvm.log10.f64", "d", "d"); |
|
299 } |
|
300 |
|
301 Value* SharkBuilder::pow() { |
|
302 return make_function("llvm.pow.f64", "dd", "d"); |
|
303 } |
|
304 |
|
305 Value* SharkBuilder::exp() { |
|
306 return make_function("llvm.exp.f64", "d", "d"); |
|
307 } |
|
308 |
|
309 Value* SharkBuilder::fabs() { |
|
310 return make_function((address) ::fabs, "d", "d"); |
|
311 } |
|
312 |
|
313 Value* SharkBuilder::unsafe_field_offset_to_byte_offset() { |
|
314 extern jlong Unsafe_field_offset_to_byte_offset(jlong field_offset); |
|
315 return make_function((address) Unsafe_field_offset_to_byte_offset, "l", "l"); |
|
316 } |
|
317 |
|
318 Value* SharkBuilder::osr_migration_end() { |
|
319 return make_function((address) SharedRuntime::OSR_migration_end, "C", "v"); |
|
320 } |
|
321 |
|
322 // Semi-VM calls |
|
323 |
|
324 Value* SharkBuilder::throw_StackOverflowError() { |
|
325 return make_function((address) ZeroStack::handle_overflow, "T", "v"); |
|
326 } |
|
327 |
|
328 Value* SharkBuilder::uncommon_trap() { |
|
329 return make_function((address) SharkRuntime::uncommon_trap, "Ti", "i"); |
|
330 } |
|
331 |
|
332 Value* SharkBuilder::deoptimized_entry_point() { |
|
333 return make_function((address) CppInterpreter::main_loop, "iT", "v"); |
|
334 } |
|
335 |
|
336 // Native-Java transition |
|
337 |
|
338 Value* SharkBuilder::check_special_condition_for_native_trans() { |
|
339 return make_function( |
|
340 (address) JavaThread::check_special_condition_for_native_trans, |
|
341 "T", "v"); |
|
342 } |
|
343 |
|
344 // Low-level non-VM calls |
|
345 |
|
346 // The ARM-specific code here is to work around unimplemented |
|
347 // atomic exchange and memory barrier intrinsics in LLVM. |
|
348 // |
|
349 // Delegating to external functions for these would normally |
|
350 // incur a speed penalty, but Linux on ARM is a special case |
|
351 // in that atomic operations on that platform are handled by |
|
352 // external functions anyway. It would be *preferable* for |
|
353 // the calls to be hidden away in LLVM, but it's not hurting |
|
354 // performance so having the calls here is acceptable. |
|
355 // |
|
356 // If you are building Shark on a platform without atomic |
|
357 // exchange and/or memory barrier intrinsics then it is only |
|
358 // acceptable to mimic this approach if your platform cannot |
|
359 // perform these operations without delegating to a function. |
|
360 |
|
361 #ifdef ARM |
|
362 static jint zero_cmpxchg_int(volatile jint *ptr, jint oldval, jint newval) { |
|
363 return Atomic::cmpxchg(newval, ptr, oldval); |
|
364 } |
|
365 #endif // ARM |
|
366 |
|
367 Value* SharkBuilder::cmpxchg_int() { |
|
368 return make_function( |
|
369 #ifdef ARM |
|
370 (address) zero_cmpxchg_int, |
|
371 #else |
|
372 "llvm.atomic.cmp.swap.i32.p0i32", |
|
373 #endif // ARM |
|
374 "Iii", "i"); |
|
375 } |
|
376 |
|
377 #ifdef ARM |
|
378 static intptr_t zero_cmpxchg_ptr(volatile intptr_t* ptr, |
|
379 intptr_t oldval, |
|
380 intptr_t newval) { |
|
381 return Atomic::cmpxchg_ptr(newval, ptr, oldval); |
|
382 } |
|
383 #endif // ARM |
|
384 |
|
385 Value* SharkBuilder::cmpxchg_ptr() { |
|
386 return make_function( |
|
387 #ifdef ARM |
|
388 (address) zero_cmpxchg_ptr, |
|
389 #else |
|
390 "llvm.atomic.cmp.swap.i" LP64_ONLY("64") NOT_LP64("32") ".p0i" LP64_ONLY("64") NOT_LP64("32"), |
|
391 #endif // ARM |
|
392 "Xxx", "x"); |
|
393 } |
|
394 |
|
395 Value* SharkBuilder::frame_address() { |
|
396 return make_function("llvm.frameaddress", "i", "C"); |
|
397 } |
|
398 |
|
399 Value* SharkBuilder::memory_barrier() { |
|
400 return make_function( |
|
401 #ifdef ARM |
|
402 (address) 0xffff0fa0, // __kernel_dmb |
|
403 #else |
|
404 "llvm.memory.barrier", |
|
405 #endif // ARM |
|
406 "11111", "v"); |
|
407 } |
|
408 |
|
409 Value* SharkBuilder::memset() { |
|
410 #if SHARK_LLVM_VERSION >= 28 |
|
411 // LLVM 2.8 added a fifth isVolatile field for memset |
|
412 // introduced with LLVM r100304 |
|
413 return make_function("llvm.memset.i32", "Cciii", "v"); |
|
414 #else |
|
415 return make_function("llvm.memset.i32", "Ccii", "v"); |
|
416 #endif |
|
417 } |
|
418 |
|
419 Value* SharkBuilder::unimplemented() { |
|
420 return make_function((address) report_unimplemented, "Ci", "v"); |
|
421 } |
|
422 |
|
423 Value* SharkBuilder::should_not_reach_here() { |
|
424 return make_function((address) report_should_not_reach_here, "Ci", "v"); |
|
425 } |
|
426 |
|
427 Value* SharkBuilder::dump() { |
|
428 return make_function((address) SharkRuntime::dump, "Cx", "v"); |
|
429 } |
|
430 |
|
431 // Public interface to low-level non-VM calls |
|
432 |
|
433 CallInst* SharkBuilder::CreateCmpxchgInt(Value* exchange_value, |
|
434 Value* dst, |
|
435 Value* compare_value) { |
|
436 return CreateCall3(cmpxchg_int(), dst, compare_value, exchange_value); |
|
437 } |
|
438 |
|
439 CallInst* SharkBuilder::CreateCmpxchgPtr(Value* exchange_value, |
|
440 Value* dst, |
|
441 Value* compare_value) { |
|
442 return CreateCall3(cmpxchg_ptr(), dst, compare_value, exchange_value); |
|
443 } |
|
444 |
|
445 CallInst* SharkBuilder::CreateGetFrameAddress() { |
|
446 return CreateCall(frame_address(), LLVMValue::jint_constant(0)); |
|
447 } |
|
448 |
|
449 CallInst *SharkBuilder::CreateMemoryBarrier(int flags) { |
|
450 Value *args[] = { |
|
451 LLVMValue::bit_constant((flags & BARRIER_LOADLOAD) ? 1 : 0), |
|
452 LLVMValue::bit_constant((flags & BARRIER_LOADSTORE) ? 1 : 0), |
|
453 LLVMValue::bit_constant((flags & BARRIER_STORELOAD) ? 1 : 0), |
|
454 LLVMValue::bit_constant((flags & BARRIER_STORESTORE) ? 1 : 0), |
|
455 LLVMValue::bit_constant(1)}; |
|
456 |
|
457 return CreateCall(memory_barrier(), args, args + 5); |
|
458 } |
|
459 |
|
460 CallInst* SharkBuilder::CreateMemset(Value* dst, |
|
461 Value* value, |
|
462 Value* len, |
|
463 Value* align) { |
|
464 #if SHARK_LLVM_VERSION >= 28 |
|
465 return CreateCall5(memset(), dst, value, len, align, |
|
466 LLVMValue::jint_constant(0)); |
|
467 #else |
|
468 return CreateCall4(memset(), dst, value, len, align); |
|
469 #endif |
|
470 } |
|
471 |
|
472 CallInst* SharkBuilder::CreateUnimplemented(const char* file, int line) { |
|
473 return CreateCall2( |
|
474 unimplemented(), |
|
475 CreateIntToPtr( |
|
476 LLVMValue::intptr_constant((intptr_t) file), |
|
477 PointerType::getUnqual(SharkType::jbyte_type())), |
|
478 LLVMValue::jint_constant(line)); |
|
479 } |
|
480 |
|
481 CallInst* SharkBuilder::CreateShouldNotReachHere(const char* file, int line) { |
|
482 return CreateCall2( |
|
483 should_not_reach_here(), |
|
484 CreateIntToPtr( |
|
485 LLVMValue::intptr_constant((intptr_t) file), |
|
486 PointerType::getUnqual(SharkType::jbyte_type())), |
|
487 LLVMValue::jint_constant(line)); |
|
488 } |
|
489 |
|
490 #ifndef PRODUCT |
|
491 CallInst* SharkBuilder::CreateDump(Value* value) { |
|
492 const char *name; |
|
493 if (value->hasName()) |
|
494 // XXX this leaks, but it's only debug code |
|
495 name = strdup(value->getName().str().c_str()); |
|
496 else |
|
497 name = "unnamed_value"; |
|
498 |
|
499 if (isa<PointerType>(value->getType())) |
|
500 value = CreatePtrToInt(value, SharkType::intptr_type()); |
|
501 else if (value->getType()-> |
|
502 #if SHARK_LLVM_VERSION >= 27 |
|
503 isIntegerTy() |
|
504 #else |
|
505 isInteger() |
|
506 #endif |
|
507 ) |
|
508 value = CreateIntCast(value, SharkType::intptr_type(), false); |
|
509 else |
|
510 Unimplemented(); |
|
511 |
|
512 return CreateCall2( |
|
513 dump(), |
|
514 CreateIntToPtr( |
|
515 LLVMValue::intptr_constant((intptr_t) name), |
|
516 PointerType::getUnqual(SharkType::jbyte_type())), |
|
517 value); |
|
518 } |
|
519 #endif // PRODUCT |
|
520 |
|
521 // HotSpot memory barriers |
|
522 |
|
523 void SharkBuilder::CreateUpdateBarrierSet(BarrierSet* bs, Value* field) { |
|
524 if (bs->kind() != BarrierSet::CardTableModRef) |
|
525 Unimplemented(); |
|
526 |
|
527 CreateStore( |
|
528 LLVMValue::jbyte_constant(CardTableModRefBS::dirty_card), |
|
529 CreateIntToPtr( |
|
530 CreateAdd( |
|
531 LLVMValue::intptr_constant( |
|
532 (intptr_t) ((CardTableModRefBS *) bs)->byte_map_base), |
|
533 CreateLShr( |
|
534 CreatePtrToInt(field, SharkType::intptr_type()), |
|
535 LLVMValue::intptr_constant(CardTableModRefBS::card_shift))), |
|
536 PointerType::getUnqual(SharkType::jbyte_type()))); |
|
537 } |
|
538 |
|
539 // Helpers for accessing the code buffer |
|
540 |
|
541 Value* SharkBuilder::code_buffer_address(int offset) { |
|
542 return CreateAdd( |
|
543 code_buffer()->base_pc(), |
|
544 LLVMValue::intptr_constant(offset)); |
|
545 } |
|
546 |
|
547 Value* SharkBuilder::CreateInlineOop(jobject object, const char* name) { |
|
548 return CreateLoad( |
|
549 CreateIntToPtr( |
|
550 code_buffer_address(code_buffer()->inline_oop(object)), |
|
551 PointerType::getUnqual(SharkType::oop_type())), |
|
552 name); |
|
553 } |
|
554 |
|
555 Value* SharkBuilder::CreateInlineData(void* data, |
|
556 size_t size, |
|
557 const Type* type, |
|
558 const char* name) { |
|
559 return CreateIntToPtr( |
|
560 code_buffer_address(code_buffer()->inline_data(data, size)), |
|
561 type, |
|
562 name); |
|
563 } |
|
564 |
|
565 // Helpers for creating basic blocks. |
|
566 |
|
567 BasicBlock* SharkBuilder::GetBlockInsertionPoint() const { |
|
568 BasicBlock *cur = GetInsertBlock(); |
|
569 |
|
570 // BasicBlock::Create takes an insertBefore argument, so |
|
571 // we need to find the block _after_ the current block |
|
572 Function::iterator iter = cur->getParent()->begin(); |
|
573 Function::iterator end = cur->getParent()->end(); |
|
574 while (iter != end) { |
|
575 iter++; |
|
576 if (&*iter == cur) { |
|
577 iter++; |
|
578 break; |
|
579 } |
|
580 } |
|
581 |
|
582 if (iter == end) |
|
583 return NULL; |
|
584 else |
|
585 return iter; |
|
586 } |
|
587 |
|
588 BasicBlock* SharkBuilder::CreateBlock(BasicBlock* ip, const char* name) const { |
|
589 return BasicBlock::Create( |
|
590 SharkContext::current(), name, GetInsertBlock()->getParent(), ip); |
|
591 } |