SharkBuilder refactoring
Gary Benson
gbenson at redhat.com
Thu Jul 30 02:18:11 PDT 2009
Hi all,
This commit is a big refactoring I've been working on this past
week or so. It mainly relates to the creation of LLVM callable
objects to represent external functions, but SharkBuilder has,
over time, ended up as a kind of storehouse of dirty hacks and
I've taken the opportunity to clean them out.
Shark code calls a certain number of external functions, and the
LLVM objects representing these were previously split between
two classes (SharkBuilder and SharkRuntime). Both classes did
much the same thing with their own callables, which is messy.
This patch puts all callables into SharkBuilder.
The other thing was that such callables were created when Shark
was initialized, and cached for the lifetime of the VM. This
doesn't actually work -- if a you free an LLVM function, it
would free the callables in it, and everything else would bomb.
In the new code, callables are created on the fly, and never
cached.
One consequence of this patch is that Shark will no longer work
with LLVM 2.4 on AMD64, so if you're building on AMD64 you need
to upgrade to 2.5.
Cheers,
Gary
--
http://gbenson.net/
-------------- next part --------------
diff -r ff01867e1a2a -r 051ca564791d ChangeLog
--- a/ChangeLog Wed Jul 29 10:57:38 2009 -0400
+++ b/ChangeLog Thu Jul 30 04:51:32 2009 -0400
@@ -1,3 +1,79 @@
+2009-07-30 Gary Benson <gbenson at redhat.com>
+
+ * ports/hotspot/src/share/vm/shark/sharkRuntime.hpp:
+ * ports/hotspot/src/share/vm/shark/sharkRuntime.cpp:
+ Moved everything except the actual methods called by
+ JIT-compiled code into SharkBuilder.
+
+ * ports/hotspot/src/share/vm/shark/sharkBuilder.hpp
+ * ports/hotspot/src/share/vm/shark/sharkBuilder.cpp
+ Merged code to create LLVM callable objects for runtime
+ methods from SharkRuntime, and refactored it (and the
+ existing code to create LLVM callable objects for LLVM
+ intrinsics) to create such objects on the fly.
+
+ * ports/hotspot/src/share/vm/shark/sharkCompiler.hpp
+ (SharkCompiler::_builder): Removed.
+ (SharkCompiler::builder): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkInvariants.hpp
+ (SharkCompileInvariants::SharkCompileInvariants): Take a new
+ argument, builder, and store it.
+ (SharkCompileInvariants::builder): Updated.
+ (SharkCompileInvariants::code_buffer): New method.
+ (SharkTargetInvariants::SharkTargetInvariants): Take a new
+ argument, builder, and pass it along to SharkCompileInvariants
+ constructor.
+ * ports/hotspot/src/share/vm/shark/sharkFunction.hpp
+ (SharkFunction::build): Take a new argument, builder, and pass
+ it along to SharkFunction consructor.
+ (SharkFunction::SharkFunction): Take a new argument, builder,
+ and pass it along to SharkTargetInvariants consructor.
+ * ports/hotspot/src/share/vm/shark/sharkCompiler.cpp
+ (SharkCompiler::SharkCompiler): Remove builder creation and
+ SharkRuntime initialization.
+ (SharkCompiler::compile_method): Create builder and pass it
+ to SharkFunction::build.
+
+ * ports/hotspot/src/share/vm/shark/sharkBlock.cpp
+ (SharkBlock::parse_bytecode): Updated for new style calls.
+ * ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp
+ (SharkIntrinsics::do_Math_1to1): Likewise.
+ (SharkIntrinsics::do_Math_2to1): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp
+ (SharkIntrinsics::do_intrinsic): Likewise.
+ (SharkIntrinsics::do_Math_1to1): Likewise.
+ (SharkIntrinsics::do_Math_2to1): Likewise.
+ (SharkIntrinsics::do_System_currentTimeMillis): Likewise.
+ (SharkIntrinsics::do_Unsafe_compareAndSwapInt): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp
+ (SharkTopLevelBlock::call_vm): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp
+ (SharkTopLevelBlock::zero_check_value): Likewise.
+ (SharkTopLevelBlock::check_bounds): Likewise.
+ (SharkTopLevelBlock::maybe_add_safepoint): Likewise.
+ (SharkTopLevelBlock::do_trap): Likewise.
+ (SharkTopLevelBlock::call_register_finalizer): Likewise.
+ (SharkTopLevelBlock::get_interface_callee): Likewise.
+ (SharkTopLevelBlock::do_new): Likewise.
+ (SharkTopLevelBlock::do_newarray): Likewise.
+ (SharkTopLevelBlock::do_anewarray): Likewise.
+ (SharkTopLevelBlock::do_multianewarray): Likewise.
+ (SharkTopLevelBlock::acquire_lock): Likewise.
+ (SharkTopLevelBlock::release_lock): Likewise.
+
+ * ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp
+ (SharkDecacher::start_frame): Updated for new style codebuffer access.
+ * ports/hotspot/src/share/vm/shark/sharkFunction.cpp
+ (SharkFunction::initialize): Likewise.
+
+ * ports/hotspot/src/share/vm/shark/llvmValue.hpp
+ (LLVMValue::bit_constant): New method.
+
+ * ports/hotspot/src/share/vm/shark/sharkBlock.hpp
+ (SharkBlock::call_vm_leaf): Removed.
+
+ * ports/hotspot/src/share/vm/includeDB_shark: Updated.
+
2009-07-29 Omair Majid <omajid at redhat.com>
* rt/net/sourceforge/jnlp/IconDesc.java: Add new icon kind SHORTCUT.
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/includeDB_shark
--- a/ports/hotspot/src/share/vm/includeDB_shark Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/includeDB_shark Thu Jul 30 04:51:32 2009 -0400
@@ -72,7 +72,6 @@
sharkBlock.cpp sharkBlock.hpp
sharkBlock.cpp sharkBuilder.hpp
sharkBlock.cpp sharkConstant.hpp
-sharkBlock.cpp sharkRuntime.hpp
sharkBlock.cpp sharkState.hpp
sharkBlock.cpp sharkValue.hpp
@@ -149,7 +148,6 @@
sharkCompiler.cpp sharkEntry.hpp
sharkCompiler.cpp sharkFunction.hpp
sharkCompiler.cpp sharkMemoryManager.hpp
-sharkCompiler.cpp sharkRuntime.hpp
sharkCompiler.hpp abstractCompiler.hpp
sharkCompiler.hpp ciEnv.hpp
@@ -212,7 +210,6 @@
sharkIntrinsics.cpp llvmHeaders.hpp
sharkIntrinsics.cpp shark_globals.hpp
sharkIntrinsics.cpp sharkIntrinsics.hpp
-sharkIntrinsics.cpp sharkRuntime.hpp
sharkIntrinsics.cpp sharkState.hpp
sharkIntrinsics.cpp sharkValue.hpp
@@ -246,15 +243,12 @@
sharkRuntime.cpp deoptimization.hpp
sharkRuntime.cpp llvmHeaders.hpp
sharkRuntime.cpp klassOop.hpp
-sharkRuntime.cpp sharkBuilder.hpp
sharkRuntime.cpp sharkRuntime.hpp
-sharkRuntime.cpp sharkType.hpp
sharkRuntime.cpp thread.hpp
sharkRuntime.hpp allocation.hpp
sharkRuntime.hpp llvmHeaders.hpp
sharkRuntime.hpp klassOop.hpp
-sharkRuntime.hpp sharkBuilder.hpp
sharkRuntime.hpp thread.hpp
sharkState.cpp allocation.hpp
@@ -298,7 +292,6 @@
sharkTopLevelBlock.cpp sharkBuilder.hpp
sharkTopLevelBlock.cpp sharkConstant.hpp
sharkTopLevelBlock.cpp sharkInliner.hpp
-sharkTopLevelBlock.cpp sharkRuntime.hpp
sharkTopLevelBlock.cpp sharkState.hpp
sharkTopLevelBlock.cpp sharkValue.hpp
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/llvmValue.hpp
--- a/ports/hotspot/src/share/vm/shark/llvmValue.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/llvmValue.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -1,6 +1,6 @@
/*
* Copyright 1999-2007 Sun Microsystems, Inc. All Rights Reserved.
- * Copyright 2008 Red Hat, Inc.
+ * Copyright 2008, 2009 Red Hat, Inc.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@@ -77,6 +77,14 @@
}
public:
+ static llvm::ConstantInt* bit_constant(int value)
+ {
+#if SHARK_LLVM_VERSION >= 26
+ return llvm::getGlobalContext().getConstantInt(llvm::Type::Int1Ty, value, false);
+#else
+ return llvm::ConstantInt::get(llvm::Type::Int1Ty, value, false);
+#endif
+ }
static llvm::ConstantInt* intptr_constant(intptr_t value)
{
#if SHARK_LLVM_VERSION >= 26
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkBlock.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkBlock.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBlock.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -694,11 +694,13 @@
case Bytecodes::_f2i:
push(SharkValue::create_jint(
- call_vm_leaf(SharkRuntime::f2i(), pop()->jfloat_value()), false));
+ builder()->CreateCall(
+ builder()->f2i(), pop()->jfloat_value()), false));
break;
case Bytecodes::_f2l:
push(SharkValue::create_jlong(
- call_vm_leaf(SharkRuntime::f2l(), pop()->jfloat_value()), false));
+ builder()->CreateCall(
+ builder()->f2l(), pop()->jfloat_value()), false));
break;
case Bytecodes::_f2d:
push(SharkValue::create_jdouble(
@@ -708,11 +710,13 @@
case Bytecodes::_d2i:
push(SharkValue::create_jint(
- call_vm_leaf(SharkRuntime::d2i(), pop()->jdouble_value()), false));
+ builder()->CreateCall(
+ builder()->d2i(), pop()->jdouble_value()), false));
break;
case Bytecodes::_d2l:
push(SharkValue::create_jlong(
- call_vm_leaf(SharkRuntime::d2l(), pop()->jdouble_value()), false));
+ builder()->CreateCall(
+ builder()->d2l(), pop()->jdouble_value()), false));
break;
case Bytecodes::_d2f:
push(SharkValue::create_jfloat(
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkBlock.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkBlock.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBlock.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -174,13 +174,6 @@
protected:
virtual void do_zero_check(SharkValue* value);
- // Leaf calls
- protected:
- llvm::CallInst* call_vm_leaf(llvm::Constant* callee, llvm::Value* arg1)
- {
- return builder()->CreateCall(callee, arg1);
- }
-
// Zero checking
protected:
void check_null(SharkValue* object)
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkBuilder.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkBuilder.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBuilder.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -28,39 +28,7 @@
using namespace llvm;
-#ifdef ARM
-/*
- * ARM lacks atomic operation implementation in LLVM
- * http://llvm.org/bugs/show_bug.cgi?id=3877
- *
- * These two functions zero_cmpxchg_int_fn and zero_cmpxchg_ptr_fn
- * are defined so that they can be inserted into llvm as a workaround to
- * make shark reroute all atomic calls back to the implementation in zero.
- * The actual insertion are done in SharkBuilder::init_external_functions().
- */
-
-extern "C" {
- jint zero_cmpxchg_int_fn(volatile jint *ptr,
- jint *oldval,
- jint *newval)
- {
- return Atomic::cmpxchg(*newval,
- ptr,
- *oldval);
- }
-
- intptr_t* zero_cmpxchg_ptr_fn(volatile void* ptr,
- intptr_t* oldval,
- intptr_t* newval)
- {
- return (intptr_t *) Atomic::cmpxchg_ptr((void *) newval,
- ptr,
- (void *) oldval);
- }
-};
-#endif
-
-SharkBuilder::SharkBuilder(SharkCompiler* compiler)
+SharkBuilder::SharkBuilder(Module* module, SharkCodeBuffer* code_buffer)
#if SHARK_LLVM_VERSION >= 26
// LLVM 2.6 requires a LLVMContext during IRBuilder construction.
// getGlobalConext() returns one that can be used as long as the shark
@@ -68,149 +36,480 @@
: IRBuilder<>(getGlobalContext()),
#else
: IRBuilder<>(),
-#endif
- _compiler(compiler)
+#endif // SHARK_LLVM_VERSION >= 26
+ _module(module),
+ _code_buffer(code_buffer)
{
- init_external_functions();
}
-Constant* SharkBuilder::make_function(intptr_t addr,
- const FunctionType* sig,
- const char* name)
+// Helpers for accessing structures
+Value* SharkBuilder::CreateAddressOfStructEntry(Value* base,
+ ByteSize offset,
+ const Type* type,
+ const char* name)
{
- Constant *func = make_pointer(addr, sig);
+ return CreateBitCast(CreateStructGEP(base, in_bytes(offset)), type, name);
+}
+
+LoadInst* SharkBuilder::CreateValueOfStructEntry(Value* base,
+ ByteSize offset,
+ const Type* type,
+ const char* name)
+{
+ return CreateLoad(
+ CreateAddressOfStructEntry(
+ base, offset, PointerType::getUnqual(type)),
+ name);
+}
+
+// Helpers for accessing arrays
+
+LoadInst* SharkBuilder::CreateArrayLength(Value* arrayoop)
+{
+ return CreateValueOfStructEntry(
+ arrayoop, in_ByteSize(arrayOopDesc::length_offset_in_bytes()),
+ SharkType::jint_type(), "length");
+}
+
+Value* SharkBuilder::CreateArrayAddress(Value* arrayoop,
+ const Type* element_type,
+ int element_bytes,
+ ByteSize base_offset,
+ Value* index,
+ const char* name)
+{
+ Value* offset = CreateIntCast(index, SharkType::intptr_type(), false);
+ if (element_bytes != 1)
+ offset = CreateShl(
+ offset,
+ LLVMValue::intptr_constant(exact_log2(element_bytes)));
+ offset = CreateAdd(
+ LLVMValue::intptr_constant(in_bytes(base_offset)), offset);
+
+ return CreateIntToPtr(
+ CreateAdd(CreatePtrToInt(arrayoop, SharkType::intptr_type()), offset),
+ PointerType::getUnqual(element_type),
+ name);
+}
+
+Value* SharkBuilder::CreateArrayAddress(Value* arrayoop,
+ BasicType basic_type,
+ ByteSize base_offset,
+ Value* index,
+ const char* name)
+{
+ return CreateArrayAddress(
+ arrayoop,
+ SharkType::to_arrayType(basic_type),
+ type2aelembytes(basic_type),
+ base_offset, index, name);
+}
+
+Value* SharkBuilder::CreateArrayAddress(Value* arrayoop,
+ BasicType basic_type,
+ Value* index,
+ const char* name)
+{
+ return CreateArrayAddress(
+ arrayoop, basic_type,
+ in_ByteSize(arrayOopDesc::base_offset_in_bytes(basic_type)),
+ index, name);
+}
+
+// Helpers for creating intrinsics and external functions.
+
+const Type* SharkBuilder::make_type(char type, bool void_ok)
+{
+ switch (type) {
+ // Primitive types
+ case 'c':
+ return SharkType::jbyte_type();
+ case 'i':
+ return SharkType::jint_type();
+ case 'l':
+ return SharkType::jlong_type();
+ case 'x':
+ return SharkType::intptr_type();
+ case 'f':
+ return SharkType::jfloat_type();
+ case 'd':
+ return SharkType::jdouble_type();
+
+ // Pointers to primitive types
+ case 'C':
+ case 'I':
+ case 'L':
+ case 'X':
+ case 'F':
+ case 'D':
+ return PointerType::getUnqual(make_type(tolower(type), false));
+
+ // VM objects
+ case 'T':
+ return SharkType::thread_type();
+ case 'M':
+ return PointerType::getUnqual(SharkType::monitor_type());
+ case 'O':
+ return SharkType::oop_type();
+
+ // Miscellaneous
+ case 'v':
+ assert(void_ok, "should be");
+ return Type::VoidTy;
+ case '1':
+ return Type::Int1Ty;
+
+ default:
+ ShouldNotReachHere();
+ }
+}
+
+const FunctionType* SharkBuilder::make_ftype(const char* params,
+ const char* ret)
+{
+ std::vector<const Type*> param_types;
+ for (const char* c = params; *c; c++)
+ param_types.push_back(make_type(*c, false));
+
+ assert(strlen(ret) == 1, "should be");
+ const Type *return_type = make_type(*ret, true);
+
+ return FunctionType::get(return_type, param_types, false);
+}
+
+// Create an object representing an intrinsic or external function by
+// referencing the symbol by name. This is the LLVM-style approach,
+// but it cannot be used on functions within libjvm.so its symbols
+// are not exported. Note that you cannot make this work simply by
+// exporting the symbols, as some symbols have the same names as
+// symbols in the standard libraries (eg, atan2, fabs) and would
+// obscure them were they visible.
+Value* SharkBuilder::make_function(const char* name,
+ const char* params,
+ const char* ret)
+{
+ return module()->getOrInsertFunction(name, make_ftype(params, ret));
+}
+
+// Create an object representing an external function by inlining a
+// function pointer in the code. This is not the LLVM way, but it's
+// the only way to access functions in libjvm.so and functions like
+// __kernel_dmb on ARM which is accessed via an absolute address.
+Value* SharkBuilder::make_function(address func,
+ const char* params,
+ const char* ret)
+{
+ return CreateIntToPtr(
+ LLVMValue::intptr_constant((intptr_t) func),
+ PointerType::getUnqual(make_ftype(params, ret)));
+}
+
+// VM calls
+
+Value* SharkBuilder::find_exception_handler()
+{
+ return make_function(
+ (address) SharkRuntime::find_exception_handler, "TIi", "i");
+}
+
+Value* SharkBuilder::monitorenter()
+{
+ return make_function((address) SharkRuntime::monitorenter, "TM", "v");
+}
+
+Value* SharkBuilder::monitorexit()
+{
+ return make_function((address) SharkRuntime::monitorexit, "TM", "v");
+}
+
+Value* SharkBuilder::new_instance()
+{
+ return make_function((address) SharkRuntime::new_instance, "Ti", "v");
+}
+
+Value* SharkBuilder::newarray()
+{
+ return make_function((address) SharkRuntime::newarray, "Tii", "v");
+}
+
+Value* SharkBuilder::anewarray()
+{
+ return make_function((address) SharkRuntime::anewarray, "Tii", "v");
+}
+
+Value* SharkBuilder::multianewarray()
+{
+ return make_function((address) SharkRuntime::multianewarray, "TiiI", "v");
+}
+
+Value* SharkBuilder::register_finalizer()
+{
+ return make_function((address) SharkRuntime::register_finalizer, "TO", "v");
+}
+
+Value* SharkBuilder::safepoint()
+{
+ return make_function((address) SafepointSynchronize::block, "T", "v");
+}
+
+Value* SharkBuilder::throw_ArrayIndexOutOfBoundsException()
+{
+ return make_function(
+ (address) SharkRuntime::throw_ArrayIndexOutOfBoundsException, "TCii", "v");
+}
+
+Value* SharkBuilder::throw_NullPointerException()
+{
+ return make_function(
+ (address) SharkRuntime::throw_NullPointerException, "TCi", "v");
+}
+
+// High-level non-VM calls
+
+Value* SharkBuilder::f2i()
+{
+ return make_function((address) SharedRuntime::f2i, "f", "i");
+}
+
+Value* SharkBuilder::f2l()
+{
+ return make_function((address) SharedRuntime::f2l, "f", "l");
+}
+
+Value* SharkBuilder::d2i()
+{
+ return make_function((address) SharedRuntime::d2i, "d", "i");
+}
+
+Value* SharkBuilder::d2l()
+{
+ return make_function((address) SharedRuntime::d2l, "d", "l");
+}
+
+Value* SharkBuilder::is_subtype_of()
+{
+ return make_function((address) SharkRuntime::is_subtype_of, "OO", "c");
+}
+
+Value* SharkBuilder::current_time_millis()
+{
+ return make_function((address) os::javaTimeMillis, "", "l");
+}
+
+Value* SharkBuilder::sin()
+{
+ return make_function("llvm.sin.f64", "d", "d");
+}
+
+Value* SharkBuilder::cos()
+{
+ return make_function("llvm.cos.f64", "d", "d");
+}
+
+Value* SharkBuilder::tan()
+{
+ return make_function((address) ::tan, "d", "d");
+}
+
+Value* SharkBuilder::atan2()
+{
+ return make_function((address) ::atan2, "dd", "d");
+}
+
+Value* SharkBuilder::sqrt()
+{
+ return make_function("llvm.sqrt.f64", "d", "d");
+}
+
+Value* SharkBuilder::log()
+{
+ return make_function("llvm.log.f64", "d", "d");
+}
+
+Value* SharkBuilder::log10()
+{
+ return make_function("llvm.log10.f64", "d", "d");
+}
+
+Value* SharkBuilder::pow()
+{
+ return make_function("llvm.pow.f64", "dd", "d");
+}
+
+Value* SharkBuilder::exp()
+{
+ return make_function("llvm.exp.f64", "d", "d");
+}
+
+Value* SharkBuilder::fabs()
+{
+ return make_function((address) ::fabs, "d", "d");
+}
+
+Value* SharkBuilder::unsafe_field_offset_to_byte_offset()
+{
+ extern jlong Unsafe_field_offset_to_byte_offset(jlong field_offset);
+ return make_function((address) Unsafe_field_offset_to_byte_offset, "l", "l");
+}
+
+// Uncommon trap
+
+Value* SharkBuilder::uncommon_trap()
+{
+ return make_function((address) SharkRuntime::uncommon_trap, "Ti", "v");
+}
+
+// Low-level non-VM calls
+
+// The ARM-specific code here is to work around unimplemented
+// atomic exchange and memory barrier intrinsics in LLVM.
+//
+// Delegating to external functions for these would normally
+// incur a speed penalty, but Linux on ARM is a special case
+// in that atomic operations on that platform are handled by
+// external functions anyway. It would be *preferable* for
+// the calls to be hidden away in LLVM, but it's not hurting
+// performance so having the calls here is acceptable.
+//
+// If you are building Shark on a platform without atomic
+// exchange and/or memory barrier intrinsics then it is only
+// acceptable to mimic this approach if your platform cannot
+// perform these operations without delegating to a function.
+
+#ifdef ARM
+static jint zero_cmpxchg_int(volatile jint *ptr, jint *oldval, jint newval)
+{
+ return Atomic::cmpxchg(*newval, ptr, *oldval);
+}
+#endif // ARM
+
+Value* SharkBuilder::cmpxchg_int()
+{
+ return make_function(
+#ifdef ARM
+ (address) zero_cmpxchg_int,
+#else
+ "llvm.atomic.cmp.swap.i32",
+#endif // ARM
+ "Iii", "i");
+}
+
+#ifdef ARM
+static intptr_t zero_cmpxchg_ptr(volatile intptr_t* ptr,
+ intptr_t* oldval,
+ intptr_t* newval)
+{
+ return Atomic::cmpxchg_ptr(*newval, ptr, *oldval);
+}
+#endif // ARM
+
+Value* SharkBuilder::cmpxchg_ptr()
+{
+ return make_function(
+#ifdef ARM
+ (address) zero_cmpxchg_ptr,
+#else
+ "llvm.atomic.cmp.swap.i" LP64_ONLY("64") NOT_LP64("32"),
+#endif // ARM
+ "Xxx", "x");
+}
+
+Value* SharkBuilder::memory_barrier()
+{
+ return make_function(
+#ifdef ARM
+ (address) 0xffff0fa0, // __kernel_dmb
+#else
+ "llvm.memory.barrier",
+#endif // ARM
+ "11111", "v");
+}
+
+Value* SharkBuilder::memset()
+{
+ return make_function("llvm.memset.i32", "Ccii", "v");
+}
+
+Value* SharkBuilder::unimplemented()
+{
+ return make_function((address) report_unimplemented, "Ci", "v");
+}
+
+Value* SharkBuilder::should_not_reach_here()
+{
+ return make_function((address) report_should_not_reach_here, "Ci", "v");
+}
+
+Value* SharkBuilder::dump()
+{
+ return make_function((address) SharkRuntime::dump, "Cx", "v");
+}
+
+// Public interface to low-level non-VM calls
+
+CallInst* SharkBuilder::CreateCmpxchgInt(Value* exchange_value,
+ Value* dst,
+ Value* compare_value)
+{
+ return CreateCall3(cmpxchg_int(), dst, compare_value, exchange_value);
+}
+
+CallInst* SharkBuilder::CreateCmpxchgPtr(Value* exchange_value,
+ Value* dst,
+ Value* compare_value)
+{
+ return CreateCall3(cmpxchg_ptr(), dst, compare_value, exchange_value);
+}
+
+CallInst *SharkBuilder::CreateMemoryBarrier(int flags)
+{
+ Value *args[] = {
+ LLVMValue::bit_constant((flags & BARRIER_LOADLOAD) ? 1 : 0),
+ LLVMValue::bit_constant((flags & BARRIER_LOADSTORE) ? 1 : 0),
+ LLVMValue::bit_constant((flags & BARRIER_STORELOAD) ? 1 : 0),
+ LLVMValue::bit_constant((flags & BARRIER_STORESTORE) ? 1 : 0),
+ LLVMValue::bit_constant(0)};
+
+ return CreateCall(memory_barrier(), args, args + 5);
+}
+
+CallInst* SharkBuilder::CreateMemset(Value* dst,
+ Value* value,
+ Value* len,
+ Value* align)
+{
+ return CreateCall4(memset(), dst, value, len, align);
+}
+
+CallInst* SharkBuilder::CreateUnimplemented(const char* file, int line)
+{
+ return CreateCall2(
+ unimplemented(),
+ CreateIntToPtr(
+ LLVMValue::intptr_constant((intptr_t) file),
+ PointerType::getUnqual(SharkType::jbyte_type())),
+ LLVMValue::jint_constant(line));
+}
+
+CallInst* SharkBuilder::CreateShouldNotReachHere(const char* file, int line)
+{
+ return CreateCall2(
+ should_not_reach_here(),
+ CreateIntToPtr(
+ LLVMValue::intptr_constant((intptr_t) file),
+ PointerType::getUnqual(SharkType::jbyte_type())),
+ LLVMValue::jint_constant(line));
+}
#ifndef PRODUCT
- ResourceMark rm;
-
- // Use a trampoline to make dumped code more readable
- Function *trampoline = (Function *) module()->getOrInsertFunction(name, sig);
- SetInsertPoint(BasicBlock::Create("", trampoline));
-
- Value **args = NEW_RESOURCE_ARRAY(Value*, trampoline->arg_size());
- Function::arg_iterator ai = trampoline->arg_begin();
- for (unsigned i = 0; i < trampoline->arg_size(); i++)
- args[i] = ai++;
-
- Value *result = CreateCall(func, args, args + trampoline->arg_size());
- if (sig->getReturnType() == Type::VoidTy)
- CreateRetVoid();
+CallInst* SharkBuilder::CreateDump(Value* value)
+{
+ const char *name;
+ if (value->hasName())
+ // XXX this leaks, but it's only debug code
+ name = strdup(value->getName().c_str());
else
- CreateRet(result);
-
- func = trampoline;
-#endif // !PRODUCT
-
- return func;
-}
-
-void SharkBuilder::init_external_functions()
-{
- std::vector<const Type*> params;
- params.push_back(PointerType::getUnqual(SharkType::jbyte_type()));
- params.push_back(SharkType::jbyte_type());
- params.push_back(SharkType::jint_type());
- params.push_back(SharkType::jint_type());
- FunctionType *type = FunctionType::get(Type::VoidTy, params, false);
- set_llvm_memset_fn(module()->getOrInsertFunction("llvm.memset.i32", type));
-
- params.clear();
- params.push_back(PointerType::getUnqual(SharkType::jint_type()));
- params.push_back(SharkType::jint_type());
- params.push_back(SharkType::jint_type());
- type = FunctionType::get(SharkType::jint_type(), params, false);
- set_llvm_cmpxchg_int_fn(
-#ifdef ARM
- make_function(
- (intptr_t) zero_cmpxchg_int_fn,
- type,
- "zero_cmpxchg_int_fn"));
-#else
- module()->getOrInsertFunction("llvm.atomic.cmp.swap.i32", type));
-#endif
-
- params.clear();
- params.push_back(PointerType::getUnqual(SharkType::intptr_type()));
- params.push_back(SharkType::intptr_type());
- params.push_back(SharkType::intptr_type());
- type = FunctionType::get(SharkType::intptr_type(), params, false);
- set_llvm_cmpxchg_ptr_fn(
-#ifdef ARM
- make_function(
- (intptr_t) zero_cmpxchg_ptr_fn,
- type,
- "zero_cmpxchg_ptr_fn"));
-#else
- module()->getOrInsertFunction(
- "llvm.atomic.cmp.swap.i" LP64_ONLY("64") NOT_LP64("32"), type));
-#endif
-
- /*
- * The five booleans passed to llvm.memory.barrier are used like this:
- * The first four arguments enables a specific barrier in this order:
- * load-load, load-store, store-load and store-store.
- * The fith argument specifies that the barrier applies to io or device
- * or uncached memory.
- */
- params.clear();
- for (int i = 0; i < 5; i++)
- params.push_back(Type::Int1Ty);
- type = FunctionType::get(Type::VoidTy, params, false);
- set_llvm_memory_barrier_fn(
-#ifdef ARM
- make_function(
- 0xffff0fa0, // __kernel_dmb
- type,
- "__kernel_dmb"));
-#else
- module()->getOrInsertFunction("llvm.memory.barrier", type));
-#endif
-
- params.clear();
- params.push_back(SharkType::jdouble_type());
- type = FunctionType::get(SharkType::jdouble_type(), params, false);
- set_llvm_sin_fn (module()->getOrInsertFunction("llvm.sin.f64", type));
- set_llvm_cos_fn (module()->getOrInsertFunction("llvm.cos.f64", type));
- set_llvm_sqrt_fn (module()->getOrInsertFunction("llvm.sqrt.f64", type));
- set_llvm_log_fn (module()->getOrInsertFunction("llvm.log.f64", type));
- set_llvm_log10_fn(module()->getOrInsertFunction("llvm.log10.f64", type));
- set_llvm_exp_fn (module()->getOrInsertFunction("llvm.exp.f64", type));
-
- params.clear();
- params.push_back(SharkType::jdouble_type());
- params.push_back(SharkType::jdouble_type());
- type = FunctionType::get(SharkType::jdouble_type(), params, false);
- set_llvm_pow_fn(module()->getOrInsertFunction("llvm.pow.f64", type));
-}
-
-CallInst* SharkBuilder::CreateDump(llvm::Value* value)
-{
- Constant *const_name;
- if (value->hasName())
-#if SHARK_LLVM_VERSION >= 26
- const_name = getGlobalContext().getConstantArray(value->getName());
- else
- const_name = getGlobalContext().getConstantArray("unnamed_value");
-#else
- const_name = ConstantArray::get(value->getName());
- else
- const_name = ConstantArray::get("unnamed_value");
-#endif
-
- Value *name = CreatePtrToInt(
- CreateStructGEP(
- new GlobalVariable(
-#if SHARK_LLVM_VERSION >= 26
- // LLVM 2.6 requires a LLVMContext during GlobalVariable construction.
- // getGlobalConext() returns one that can be used as long as the shark
- // compiler are single-threaded.
- getGlobalContext(),
-#endif
- const_name->getType(),
- true, GlobalValue::InternalLinkage,
- const_name, "dump", module()),
- 0),
- SharkType::intptr_type());
+ name = "unnamed_value";
if (isa<PointerType>(value->getType()))
value = CreatePtrToInt(value, SharkType::intptr_type());
@@ -219,65 +518,77 @@
else
Unimplemented();
- Value *args[] = {name, value};
- return CreateCall2(SharkRuntime::dump(), name, value);
+ return CreateCall2(
+ dump(),
+ CreateIntToPtr(
+ LLVMValue::intptr_constant((intptr_t) name),
+ PointerType::getUnqual(SharkType::jbyte_type())),
+ value);
+}
+#endif // PRODUCT
+
+// HotSpot memory barriers
+
+void SharkBuilder::CreateUpdateBarrierSet(BarrierSet* bs, Value* field)
+{
+ if (bs->kind() != BarrierSet::CardTableModRef)
+ Unimplemented();
+
+ CreateStore(
+ LLVMValue::jbyte_constant(CardTableModRefBS::dirty_card),
+ CreateIntToPtr(
+ CreateAdd(
+ LLVMValue::intptr_constant(
+ (intptr_t) ((CardTableModRefBS *) bs)->byte_map_base),
+ CreateLShr(
+ CreatePtrToInt(field, SharkType::intptr_type()),
+ LLVMValue::intptr_constant(CardTableModRefBS::card_shift))),
+ PointerType::getUnqual(SharkType::jbyte_type())));
}
-CallInst* SharkBuilder::CreateCmpxchgInt(Value* exchange_value,
- Value* dst,
- Value* compare_value)
+// Helpers for accessing the code buffer
+
+Value* SharkBuilder::code_buffer_address(int offset)
{
- return CreateCall3(
- llvm_cmpxchg_int_fn(), dst, compare_value, exchange_value);
+ return CreateAdd(
+ code_buffer()->base_pc(),
+ LLVMValue::intptr_constant(offset));
}
-CallInst* SharkBuilder::CreateCmpxchgPtr(Value* exchange_value,
- Value* dst,
- Value* compare_value)
+Value* SharkBuilder::CreateInlineOop(ciObject* object, const char* name)
{
- return CreateCall3(
- llvm_cmpxchg_ptr_fn(), dst, compare_value, exchange_value);
+ return CreateLoad(
+ CreateIntToPtr(
+ code_buffer_address(code_buffer()->inline_oop(object)),
+ PointerType::getUnqual(SharkType::jobject_type())),
+ name);
}
-CallInst* SharkBuilder::CreateMemset(Value* dst,
- Value* value,
- Value* len,
- Value* align)
+// Helpers for creating basic blocks.
+
+BasicBlock* SharkBuilder::GetBlockInsertionPoint() const
{
- return CreateCall4(llvm_memset_fn(), dst, value, len, align);
+ BasicBlock *cur = GetInsertBlock();
+
+ // BasicBlock::Create takes an insertBefore argument, so
+ // we need to find the block _after_ the current block
+ Function::iterator iter = cur->getParent()->begin();
+ Function::iterator end = cur->getParent()->end();
+ while (iter != end) {
+ iter++;
+ if (&*iter == cur) {
+ iter++;
+ break;
+ }
+ }
+
+ if (iter == end)
+ return NULL;
+ else
+ return iter;
}
-CallInst* SharkBuilder::CreateUnimplemented(const char* file, int line)
+BasicBlock* SharkBuilder::CreateBlock(BasicBlock* ip, const char* name) const
{
- return CreateCall2(
- SharkRuntime::unimplemented(),
- pointer_constant(file),
- LLVMValue::jint_constant(line));
-}
-
-CallInst* SharkBuilder::CreateShouldNotReachHere(const char* file, int line)
-{
- return CreateCall2(
- SharkRuntime::should_not_reach_here(),
- pointer_constant(file),
- LLVMValue::jint_constant(line));
-}
-
-CallInst *SharkBuilder::CreateMemoryBarrier(BarrierFlags flags)
-{
- Value *args[] = {
-#if SHARK_LLVM_VERSION >= 26
- getGlobalContext().getConstantInt(Type::Int1Ty, (flags & BARRIER_LOADLOAD) ? 1 : 0),
- getGlobalContext().getConstantInt(Type::Int1Ty, (flags & BARRIER_LOADSTORE) ? 1 : 0),
- getGlobalContext().getConstantInt(Type::Int1Ty, (flags & BARRIER_STORELOAD) ? 1 : 0),
- getGlobalContext().getConstantInt(Type::Int1Ty, (flags & BARRIER_STORESTORE) ? 1 : 0),
- getGlobalContext().getConstantInt(Type::Int1Ty, 0)};
-#else
- ConstantInt::get(Type::Int1Ty, (flags & BARRIER_LOADLOAD) ? 1 : 0),
- ConstantInt::get(Type::Int1Ty, (flags & BARRIER_LOADSTORE) ? 1 : 0),
- ConstantInt::get(Type::Int1Ty, (flags & BARRIER_STORELOAD) ? 1 : 0),
- ConstantInt::get(Type::Int1Ty, (flags & BARRIER_STORESTORE) ? 1 : 0),
- ConstantInt::get(Type::Int1Ty, 0)};
-#endif
- return CreateCall(llvm_memory_barrier_fn(), args, args + 5);
-}
+ return BasicBlock::Create(name, GetInsertBlock()->getParent(), ip);
+}
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkBuilder.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkBuilder.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBuilder.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -24,322 +24,150 @@
*/
class SharkBuilder : public llvm::IRBuilder<> {
- public:
- SharkBuilder(SharkCompiler* compiler);
-
- private:
- SharkCompiler* _compiler;
+ friend class SharkCompileInvariants;
public:
- SharkCompiler* compiler() const
- {
- return _compiler;
- }
+ SharkBuilder(llvm::Module* module, SharkCodeBuffer* code_buffer);
+
+ // The LLVM module and Shark code buffer we are building into.
+ private:
+ llvm::Module* _module;
+ SharkCodeBuffer* _code_buffer;
private:
llvm::Module* module() const
{
- return compiler()->module();
+ return _module;
}
- llvm::ExecutionEngine* execution_engine() const
+ protected:
+ SharkCodeBuffer* code_buffer() const
{
- return compiler()->execution_engine();
+ return _code_buffer;
}
- // Helpers for creating basic blocks
- // NB don't use unless SharkFunction::CreateBlock is unavailable
- public:
- llvm::BasicBlock* GetBlockInsertionPoint() const
- {
- llvm::BasicBlock *cur = GetInsertBlock();
-
- // BasicBlock::Create takes an insertBefore argument, so
- // we need to find the block _after_ the current block
- llvm::Function::iterator iter = cur->getParent()->begin();
- llvm::Function::iterator end = cur->getParent()->end();
- while (iter != end) {
- iter++;
- if (&*iter == cur) {
- iter++;
- break;
- }
- }
-
- if (iter == end)
- return NULL;
- else
- return iter;
- }
- llvm::BasicBlock* CreateBlock(llvm::BasicBlock* ip, const char* name="") const
- {
- return llvm::BasicBlock::Create(name, GetInsertBlock()->getParent(), ip);
- }
-
- // Helpers for accessing structures and arrays
+ // Helpers for accessing structures.
public:
llvm::Value* CreateAddressOfStructEntry(llvm::Value* base,
ByteSize offset,
const llvm::Type* type,
- const char *name = "")
- {
- return CreateBitCast(CreateStructGEP(base, in_bytes(offset)), type, name);
- }
-
+ const char *name = "");
llvm::LoadInst* CreateValueOfStructEntry(llvm::Value* base,
ByteSize offset,
const llvm::Type* type,
- const char *name = "")
- {
- return CreateLoad(
- CreateAddressOfStructEntry(
- base, offset, llvm::PointerType::getUnqual(type)),
- name);
- }
+ const char *name = "");
- llvm::LoadInst* CreateArrayLength(llvm::Value* array)
- {
- return CreateValueOfStructEntry(
- array, in_ByteSize(arrayOopDesc::length_offset_in_bytes()),
- SharkType::jint_type(), "length");
- }
-
+ // Helpers for accessing arrays.
+ public:
+ llvm::LoadInst* CreateArrayLength(llvm::Value* arrayoop);
llvm::Value* CreateArrayAddress(llvm::Value* arrayoop,
const llvm::Type* element_type,
int element_bytes,
ByteSize base_offset,
llvm::Value* index,
- const char* name = "")
- {
- llvm::Value* offset = CreateIntCast(index, SharkType::intptr_type(), false);
- if (element_bytes != 1)
- offset = CreateShl(
- offset,
- LLVMValue::intptr_constant(exact_log2(element_bytes)));
- offset = CreateAdd(
- LLVMValue::intptr_constant(in_bytes(base_offset)), offset);
-
- return CreateIntToPtr(
- CreateAdd(CreatePtrToInt(arrayoop, SharkType::intptr_type()), offset),
- llvm::PointerType::getUnqual(element_type),
- name);
- }
-
+ const char* name = "");
llvm::Value* CreateArrayAddress(llvm::Value* arrayoop,
BasicType basic_type,
ByteSize base_offset,
llvm::Value* index,
- const char* name = "")
- {
- return CreateArrayAddress(
- arrayoop,
- SharkType::to_arrayType(basic_type),
- type2aelembytes(basic_type),
- base_offset, index, name);
- }
-
+ const char* name = "");
llvm::Value* CreateArrayAddress(llvm::Value* arrayoop,
BasicType basic_type,
llvm::Value* index,
- const char* name = "")
- {
- return CreateArrayAddress(
- arrayoop, basic_type,
- in_ByteSize(arrayOopDesc::base_offset_in_bytes(basic_type)),
- index, name);
- }
+ const char* name = "");
- // Helper for making function pointers
+ // Helpers for creating intrinsics and external functions.
+ private:
+ static const llvm::Type* make_type(char type, bool void_ok);
+ static const llvm::FunctionType* make_ftype(const char* params,
+ const char* ret);
+ llvm::Value* make_function(const char* name,
+ const char* params,
+ const char* ret);
+ llvm::Value* make_function(address func,
+ const char* params,
+ const char* ret);
+
+ // Intrinsics and external functions, part 1: VM calls.
+ // These are functions declared with JRT_ENTRY and JRT_EXIT,
+ // macros which flip the thread from _thread_in_Java to
+ // _thread_in_vm and back. VM calls always safepoint, and can
+ // therefore throw exceptions. VM calls require of setup and
+ // teardown, and must be called with SharkTopLevelBlock::call_vm.
public:
- llvm::Constant* make_function(intptr_t addr,
- const llvm::FunctionType* sig,
- const char* name);
+ llvm::Value* find_exception_handler();
+ llvm::Value* monitorenter();
+ llvm::Value* monitorexit();
+ llvm::Value* new_instance();
+ llvm::Value* newarray();
+ llvm::Value* anewarray();
+ llvm::Value* multianewarray();
+ llvm::Value* register_finalizer();
+ llvm::Value* safepoint();
+ llvm::Value* throw_ArrayIndexOutOfBoundsException();
+ llvm::Value* throw_NullPointerException();
- llvm::Constant* pointer_constant(const void *ptr)
- {
-#if SHARK_LLVM_VERSION >= 25 || !defined(AMD64)
- return LLVMValue::intptr_constant((intptr_t) ptr);
-#else
- // Create a pointer constant that points at PTR. We do this by
- // creating a GlobalVariable mapped at PTR. This is a workaround
- // for http://www.llvm.org/bugs/show_bug.cgi?id=2920
+ // Intrinsics and external functions, part 2: High-level non-VM calls.
+ // These are called like normal functions. The stack is not set
+ // up for walking so they must not safepoint or throw exceptions,
+ // or call anything that might.
+ public:
+ llvm::Value* f2i();
+ llvm::Value* f2l();
+ llvm::Value* d2i();
+ llvm::Value* d2l();
+ llvm::Value* is_subtype_of();
+ llvm::Value* current_time_millis();
+ llvm::Value* sin();
+ llvm::Value* cos();
+ llvm::Value* tan();
+ llvm::Value* atan2();
+ llvm::Value* sqrt();
+ llvm::Value* log();
+ llvm::Value* log10();
+ llvm::Value* pow();
+ llvm::Value* exp();
+ llvm::Value* fabs();
+ llvm::Value* unsafe_field_offset_to_byte_offset();
- using namespace llvm;
+ // Intrinsics and external functions, part 3: Uncommon trap.
+ // This is a special case in that it is invoked like a non-VM
+ // call but it does VM call stuff. This is acceptable so long
+ // as the method that calls uncommon_trap returns to its caller
+ // immediately that uncommon_trap returns.
+ public:
+ llvm::Value* uncommon_trap();
- // This might be useful but it returns a const pointer that can't
- // be used for anything. Go figure...
-// {
-// const GlobalValue *value
-// = execution_engine()->getGlobalValueAtAddress(const_cast<void*>(ptr));
-// if (value)
-// return ConstantExpr::getPtrToInt(value, SharkType::intptr_type());
-// }
+ // Intrinsics and external functions, part 4: Low-level non-VM calls.
+ // These have the same caveats as the high-level non-VM calls
+ // above. They are not accessed directly; rather, you should
+ // access them via the various Create* methods below.
+ private:
+ llvm::Value* cmpxchg_int();
+ llvm::Value* cmpxchg_ptr();
+ llvm::Value* memory_barrier();
+ llvm::Value* memset();
+ llvm::Value* unimplemented();
+ llvm::Value* should_not_reach_here();
+ llvm::Value* dump();
- char name[128];
- snprintf(name, sizeof name - 1, "pointer_constant_%p", ptr);
-
- GlobalVariable *value = new GlobalVariable(
- SharkType::intptr_type(),
- false, GlobalValue::ExternalLinkage,
- NULL, name, module());
- execution_engine()->addGlobalMapping(value, const_cast<void*>(ptr));
-
- return ConstantExpr::getPtrToInt(value, SharkType::intptr_type());
-#endif // SHARK_LLVM_VERSION >= 25 || !AMD64
- }
-
- // Helper for making pointers
+ // Public interface to low-level non-VM calls.
public:
- llvm::Constant* make_pointer(intptr_t addr, const llvm::Type* type)
- {
- return llvm::ConstantExpr::getIntToPtr(
- LLVMValue::intptr_constant(addr),
- llvm::PointerType::getUnqual(type));
- }
-
- // External functions (and intrinsics)
- private:
- llvm::Constant* _llvm_cmpxchg_int_fn;
- llvm::Constant* _llvm_cmpxchg_ptr_fn;
- llvm::Constant* _llvm_memory_barrier_fn;
- llvm::Constant* _llvm_memset_fn;
- llvm::Constant* _llvm_sin_fn;
- llvm::Constant* _llvm_cos_fn;
- llvm::Constant* _llvm_sqrt_fn;
- llvm::Constant* _llvm_log_fn;
- llvm::Constant* _llvm_log10_fn;
- llvm::Constant* _llvm_pow_fn;
- llvm::Constant* _llvm_exp_fn;
-
- void set_llvm_cmpxchg_int_fn(llvm::Constant* llvm_cmpxchg_int_fn)
- {
- _llvm_cmpxchg_int_fn = llvm_cmpxchg_int_fn;
- }
- void set_llvm_cmpxchg_ptr_fn(llvm::Constant* llvm_cmpxchg_ptr_fn)
- {
- _llvm_cmpxchg_ptr_fn = llvm_cmpxchg_ptr_fn;
- }
- void set_llvm_memory_barrier_fn(llvm::Constant* llvm_memory_barrier_fn)
- {
- _llvm_memory_barrier_fn = llvm_memory_barrier_fn;
- }
- void set_llvm_memset_fn(llvm::Constant* llvm_memset_fn)
- {
- _llvm_memset_fn = llvm_memset_fn;
- }
- void set_llvm_sin_fn(llvm::Constant* llvm_sin_fn)
- {
- _llvm_sin_fn = llvm_sin_fn;
- }
- void set_llvm_cos_fn(llvm::Constant* llvm_cos_fn)
- {
- _llvm_cos_fn = llvm_cos_fn;
- }
- void set_llvm_sqrt_fn(llvm::Constant* llvm_sqrt_fn)
- {
- _llvm_sqrt_fn = llvm_sqrt_fn;
- }
- void set_llvm_log_fn(llvm::Constant* llvm_log_fn)
- {
- _llvm_log_fn = llvm_log_fn;
- }
- void set_llvm_log10_fn(llvm::Constant* llvm_log10_fn)
- {
- _llvm_log10_fn = llvm_log10_fn;
- }
- void set_llvm_pow_fn(llvm::Constant* llvm_pow_fn)
- {
- _llvm_pow_fn = llvm_pow_fn;
- }
- void set_llvm_exp_fn(llvm::Constant* llvm_exp_fn)
- {
- _llvm_exp_fn = llvm_exp_fn;
- }
-
- void init_external_functions();
-
- protected:
- llvm::Constant* llvm_cmpxchg_int_fn() const
- {
- return _llvm_cmpxchg_int_fn;
- }
- llvm::Constant* llvm_cmpxchg_ptr_fn() const
- {
- return _llvm_cmpxchg_ptr_fn;
- }
- llvm::Constant* llvm_memory_barrier_fn() const
- {
- return _llvm_memory_barrier_fn;
- }
- llvm::Constant* llvm_memset_fn() const
- {
- return _llvm_memset_fn;
- }
-
- public:
- llvm::Constant* llvm_sin_fn() const
- {
- return _llvm_sin_fn;
- }
- llvm::Constant* llvm_cos_fn() const
- {
- return _llvm_cos_fn;
- }
- llvm::Constant* llvm_sqrt_fn() const
- {
- return _llvm_sqrt_fn;
- }
- llvm::Constant* llvm_log_fn() const
- {
- return _llvm_log_fn;
- }
- llvm::Constant* llvm_log10_fn() const
- {
- return _llvm_log10_fn;
- }
- llvm::Constant* llvm_pow_fn() const
- {
- return _llvm_pow_fn;
- }
- llvm::Constant* llvm_exp_fn() const
- {
- return _llvm_exp_fn;
- }
-
- public:
- llvm::CallInst* CreateDump(llvm::Value* value);
+ llvm::CallInst* CreateCmpxchgInt(llvm::Value* exchange_value,
+ llvm::Value* dst,
+ llvm::Value* compare_value);
+ llvm::CallInst* CreateCmpxchgPtr(llvm::Value* exchange_value,
+ llvm::Value* dst,
+ llvm::Value* compare_value);
+ llvm::CallInst* CreateMemoryBarrier(int flags);
llvm::CallInst* CreateMemset(llvm::Value* dst,
llvm::Value* value,
llvm::Value* len,
llvm::Value* align);
- llvm::CallInst* CreateCmpxchgInt(llvm::Value* exchange_value,
- llvm::Value* dst,
- llvm::Value* compare_value);
- llvm::CallInst* CreateCmpxchgPtr(llvm::Value* exchange_value,
- llvm::Value* dst,
- llvm::Value* compare_value);
+ llvm::CallInst* CreateUnimplemented(const char* file, int line);
llvm::CallInst* CreateShouldNotReachHere(const char* file, int line);
- llvm::CallInst* CreateUnimplemented(const char* file, int line);
-
- // HotSpot memory barriers
- public:
- void CreateUpdateBarrierSet(BarrierSet* bs, llvm::Value* field)
- {
- if (bs->kind() != BarrierSet::CardTableModRef) {
- Unimplemented();
- }
-
- CreateStore(
- LLVMValue::jbyte_constant(CardTableModRefBS::dirty_card),
- CreateIntToPtr(
- CreateAdd(
- pointer_constant(((CardTableModRefBS *) bs)->byte_map_base),
- CreateLShr(
- CreatePtrToInt(field, SharkType::intptr_type()),
- LLVMValue::intptr_constant(CardTableModRefBS::card_shift))),
- llvm::PointerType::getUnqual(SharkType::jbyte_type())));
- }
-
- // Hardware memory barriers
+ NOT_PRODUCT(llvm::CallInst* CreateDump(llvm::Value* value));
+
+ // Flags for CreateMemoryBarrier.
public:
enum BarrierFlags {
BARRIER_LOADLOAD = 1,
@@ -348,48 +176,20 @@
BARRIER_STORESTORE = 8
};
+ // HotSpot memory barriers
public:
- llvm::CallInst* CreateMemoryBarrier(BarrierFlags flags);
+ void CreateUpdateBarrierSet(BarrierSet* bs, llvm::Value* field);
- // Alignment
+ // Helpers for accessing the code buffer.
public:
- llvm::Value* CreateAlign(llvm::Value* x, intptr_t s, const char* name = "")
- {
- assert(is_power_of_2(s), "should be");
- return CreateAnd(
- CreateAdd(x, LLVMValue::intptr_constant(s - 1)),
- LLVMValue::intptr_constant(~(s - 1)),
- name);
- }
+ llvm::Value* code_buffer_address(int offset);
+ llvm::Value* CreateInlineOop(ciObject* object, const char* name = "");
- // CodeBuffer interface
- private:
- SharkCodeBuffer* _code_buffer;
-
+ // Helpers for creating basic blocks.
+ // NB don't use unless SharkFunction::CreateBlock is unavailable.
+ // XXX these are hacky and should be removed.
public:
- SharkCodeBuffer* code_buffer() const
- {
- return _code_buffer;
- }
- void set_code_buffer(SharkCodeBuffer* code_buffer)
- {
- _code_buffer = code_buffer;
- }
-
- public:
- llvm::Value* code_buffer_address(int offset)
- {
- return CreateAdd(
- code_buffer()->base_pc(), LLVMValue::intptr_constant(offset));
- }
-
- public:
- llvm::Value* CreateInlineOop(ciObject* object, const char* name = "")
- {
- return CreateLoad(
- CreateIntToPtr(
- code_buffer_address(code_buffer()->inline_oop(object)),
- llvm::PointerType::getUnqual(SharkType::jobject_type())),
- name);
- }
+ llvm::BasicBlock* GetBlockInsertionPoint() const;
+ llvm::BasicBlock* CreateBlock(llvm::BasicBlock* ip,
+ const char* name="") const;
};
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -31,7 +31,7 @@
void SharkDecacher::start_frame()
{
// Start recording the debug information
- _pc_offset = builder()->code_buffer()->create_unique_offset();
+ _pc_offset = code_buffer()->create_unique_offset();
_oopmap = new OopMap(
oopmap_slot_munge(function()->oopmap_frame_size()),
oopmap_slot_munge(arg_size()));
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkCompiler.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkCompiler.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkCompiler.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -53,9 +53,6 @@
_module = new Module("shark");
#endif
- // Create the builder to build our functions
- _builder = new SharkBuilder(this);
-
#if SHARK_LLVM_VERSION >= 26
// If we have a native target, initialize it to ensure it is linked in and
// usable by the JIT.
@@ -82,7 +79,6 @@
// Initialize Shark components that need it
SharkType::initialize();
- SharkRuntime::initialize(builder());
mark_initialized();
}
@@ -137,22 +133,19 @@
env->debug_info()->set_oopmaps(&oopmaps);
env->set_dependencies(new Dependencies(env));
- // Create the code buffer and hook it into the builder
+ // Create the code buffer and builder
SharkCodeBuffer cb(env->oop_recorder());
- builder()->set_code_buffer(&cb);
+ SharkBuilder builder(module(), &cb);
// Emit the entry point
SharkEntry *entry = (SharkEntry *) cb.malloc(sizeof(SharkEntry));
// Build the LLVM IR for the method
- Function *function = SharkFunction::build(this, env, flow, name);
+ Function *function = SharkFunction::build(this, env, &builder, flow, name);
if (SharkPrintBitcodeOf != NULL) {
if (!fnmatch(SharkPrintBitcodeOf, name, 0))
function->dump();
}
-
- // Unhook the code buffer
- builder()->set_code_buffer(NULL);
// Compile to native code
#ifndef PRODUCT
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkCompiler.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkCompiler.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkCompiler.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -22,8 +22,6 @@
* have any questions.
*
*/
-
-class SharkBuilder;
class SharkCompiler : public AbstractCompiler {
public:
@@ -50,7 +48,6 @@
// LLVM interface
private:
llvm::Module* _module;
- SharkBuilder* _builder;
SharkMemoryManager* _memory_manager;
llvm::ExecutionEngine* _execution_engine;
@@ -58,10 +55,6 @@
llvm::Module* module() const
{
return _module;
- }
- SharkBuilder* builder() const
- {
- return _builder;
}
SharkMemoryManager* memory_manager() const
{
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkFunction.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkFunction.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkFunction.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -42,7 +42,7 @@
method->setName("method");
Argument *base_pc = ai++;
base_pc->setName("base_pc");
- builder()->code_buffer()->set_base_pc(base_pc);
+ code_buffer()->set_base_pc(base_pc);
Argument *thread = ai++;
thread->setName("thread");
set_thread(thread);
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkFunction.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkFunction.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkFunction.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -30,19 +30,21 @@
public:
static llvm::Function* build(SharkCompiler* compiler,
ciEnv* env,
+ SharkBuilder* builder,
ciTypeFlow* flow,
const char* name)
{
- SharkFunction function(compiler, env, flow, name);
+ SharkFunction function(compiler, env, builder, flow, name);
return function.function();
}
private:
SharkFunction(SharkCompiler* compiler,
ciEnv* env,
+ SharkBuilder* builder,
ciTypeFlow* flow,
const char* name)
- : SharkTargetInvariants(compiler, env, flow) { initialize(name); }
+ : SharkTargetInvariants(compiler, env, builder, flow) { initialize(name); }
private:
void initialize(const char* name);
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -92,34 +92,34 @@
do_Math_minmax(llvm::ICmpInst::ICMP_SGE);
break;
case vmIntrinsics::_dabs:
- do_Math_1to1(SharkRuntime::fabs());
+ do_Math_1to1(builder()->fabs());
break;
case vmIntrinsics::_dsin:
- do_Math_1to1(builder()->llvm_sin_fn());
+ do_Math_1to1(builder()->sin());
break;
case vmIntrinsics::_dcos:
- do_Math_1to1(builder()->llvm_cos_fn());
+ do_Math_1to1(builder()->cos());
break;
case vmIntrinsics::_dtan:
- do_Math_1to1(SharkRuntime::tan());
+ do_Math_1to1(builder()->tan());
break;
case vmIntrinsics::_datan2:
- do_Math_2to1(SharkRuntime::atan2());
+ do_Math_2to1(builder()->atan2());
break;
case vmIntrinsics::_dsqrt:
- do_Math_1to1(builder()->llvm_sqrt_fn());
+ do_Math_1to1(builder()->sqrt());
break;
case vmIntrinsics::_dlog:
- do_Math_1to1(builder()->llvm_log_fn());
+ do_Math_1to1(builder()->log());
break;
case vmIntrinsics::_dlog10:
- do_Math_1to1(builder()->llvm_log10_fn());
+ do_Math_1to1(builder()->log10());
break;
case vmIntrinsics::_dpow:
- do_Math_2to1(builder()->llvm_pow_fn());
+ do_Math_2to1(builder()->pow());
break;
case vmIntrinsics::_dexp:
- do_Math_1to1(builder()->llvm_exp_fn());
+ do_Math_1to1(builder()->exp());
break;
// java.lang.Object
@@ -181,7 +181,7 @@
sa->zero_checked() && sb->zero_checked()));
}
-void SharkIntrinsics::do_Math_1to1(Constant *function)
+void SharkIntrinsics::do_Math_1to1(Value *function)
{
SharkValue *empty = state()->pop();
assert(empty == NULL, "should be");
@@ -192,7 +192,7 @@
state()->push(NULL);
}
-void SharkIntrinsics::do_Math_2to1(Constant *function)
+void SharkIntrinsics::do_Math_2to1(Value *function)
{
SharkValue *empty = state()->pop();
assert(empty == NULL, "should be");
@@ -235,7 +235,7 @@
{
state()->push(
SharkValue::create_jlong(
- builder()->CreateCall(SharkRuntime::current_time_millis()),
+ builder()->CreateCall(builder()->current_time_millis()),
false));
state()->push(NULL);
}
@@ -264,7 +264,7 @@
// Convert the offset
offset = builder()->CreateCall(
- SharkRuntime::unsafe_field_offset_to_byte_offset(),
+ builder()->unsafe_field_offset_to_byte_offset(),
offset);
// Locate the field
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -46,8 +46,8 @@
private:
void do_Math_minmax(llvm::ICmpInst::Predicate p);
- void do_Math_1to1(llvm::Constant* function);
- void do_Math_2to1(llvm::Constant* function);
+ void do_Math_1to1(llvm::Value* function);
+ void do_Math_2to1(llvm::Value* function);
void do_Object_getClass();
void do_System_currentTimeMillis();
void do_Thread_currentThread();
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkInvariants.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkInvariants.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkInvariants.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -31,25 +31,30 @@
class SharkCompileInvariants : public ResourceObj {
protected:
- SharkCompileInvariants(SharkCompiler* compiler, ciEnv* env)
+ SharkCompileInvariants(SharkCompiler* compiler,
+ ciEnv* env,
+ SharkBuilder* builder)
: _compiler(compiler),
_env(env),
+ _builder(builder),
_thread(NULL) {}
SharkCompileInvariants(const SharkCompileInvariants* parent)
: _compiler(parent->_compiler),
_env(parent->_env),
+ _builder(parent->_builder),
_thread(parent->_thread) {}
private:
SharkCompiler* _compiler;
ciEnv* _env;
+ SharkBuilder* _builder;
llvm::Value* _thread;
// The SharkCompiler that is compiling this method. Holds the
- // classes that form the interface with LLVM (the builder, the
- // module, the memory manager, etc) and provides the compile()
- // method to convert LLVM functions to native code.
+ // classes that form the interface with LLVM (the module, the
+ // memory manager, etc) and provides the compile() method to
+ // convert LLVM functions to native code.
protected:
SharkCompiler* compiler() const
{
@@ -71,6 +76,13 @@
return _env;
}
+ // The SharkBuilder that is used to build LLVM IR.
+ protected:
+ SharkBuilder* builder() const
+ {
+ return _builder;
+ }
+
// Pointer to this thread's JavaThread object. This is not
// available until a short way into SharkFunction creation
// so a setter is required. Assertions are used to enforce
@@ -89,10 +101,6 @@
// Objects that handle various aspects of the compilation.
protected:
- SharkBuilder* builder() const
- {
- return compiler()->builder();
- }
DebugInformationRecorder* debug_info() const
{
return env()->debug_info();
@@ -100,6 +108,10 @@
Dependencies* dependencies() const
{
return env()->dependencies();
+ }
+ SharkCodeBuffer* code_buffer() const
+ {
+ return builder()->code_buffer();
}
// That well-known class...
@@ -112,8 +124,11 @@
class SharkTargetInvariants : public SharkCompileInvariants {
protected:
- SharkTargetInvariants(SharkCompiler* compiler, ciEnv* env, ciTypeFlow* flow)
- : SharkCompileInvariants(compiler, env),
+ SharkTargetInvariants(SharkCompiler* compiler,
+ ciEnv* env,
+ SharkBuilder* builder,
+ ciTypeFlow* flow)
+ : SharkCompileInvariants(compiler, env, builder),
_target(flow->method()),
_flow(flow),
_max_monitors(count_monitors()) {}
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkRuntime.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkRuntime.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkRuntime.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -28,222 +28,9 @@
using namespace llvm;
-// VM calls
-Constant* SharkRuntime::_find_exception_handler;
-Constant* SharkRuntime::_monitorenter;
-Constant* SharkRuntime::_monitorexit;
-Constant* SharkRuntime::_new_instance;
-Constant* SharkRuntime::_newarray;
-Constant* SharkRuntime::_anewarray;
-Constant* SharkRuntime::_multianewarray;
-Constant* SharkRuntime::_register_finalizer;
-Constant* SharkRuntime::_safepoint;
-Constant* SharkRuntime::_throw_ArrayIndexOutOfBoundsException;
-Constant* SharkRuntime::_throw_NullPointerException;
-
-// Leaf calls
-Constant* SharkRuntime::_f2i;
-Constant* SharkRuntime::_f2l;
-Constant* SharkRuntime::_d2i;
-Constant* SharkRuntime::_d2l;
-
-// Non-VM calls
-Constant* SharkRuntime::_dump;
-Constant* SharkRuntime::_is_subtype_of;
-Constant* SharkRuntime::_should_not_reach_here;
-Constant* SharkRuntime::_unimplemented;
-Constant* SharkRuntime::_uncommon_trap;
-Constant* SharkRuntime::_current_time_millis;
-Constant* SharkRuntime::_fabs;
-Constant* SharkRuntime::_tan;
-Constant* SharkRuntime::_atan2;
-Constant* SharkRuntime::_unsafe_field_offset_to_byte_offset;
-
-extern jlong Unsafe_field_offset_to_byte_offset(jlong field_offset);
-
-void SharkRuntime::initialize(SharkBuilder* builder)
-{
- // VM calls
- std::vector<const Type*> params;
- params.push_back(SharkType::thread_type());
- params.push_back(PointerType::getUnqual(SharkType::jint_type()));
- params.push_back(SharkType::jint_type());
- _find_exception_handler = builder->make_function(
- (intptr_t) find_exception_handler_C,
- FunctionType::get(SharkType::jint_type(), params, false),
- "SharkRuntime__find_exception_handler");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(PointerType::getUnqual(SharkType::monitor_type()));
- _monitorenter = builder->make_function(
- (intptr_t) monitorenter_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__monitorenter");
- _monitorexit = builder->make_function(
- (intptr_t) monitorexit_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__monitorexit");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(SharkType::jint_type());
- _new_instance = builder->make_function(
- (intptr_t) new_instance_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__new_instance");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(SharkType::jint_type());
- params.push_back(SharkType::jint_type());
- _newarray = builder->make_function(
- (intptr_t) newarray_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__newarray");
- _anewarray = builder->make_function(
- (intptr_t) anewarray_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__anewarray");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(SharkType::jint_type());
- params.push_back(SharkType::jint_type());
- params.push_back(PointerType::getUnqual(SharkType::jint_type()));
- _multianewarray = builder->make_function(
- (intptr_t) multianewarray_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__multianewarray");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(SharkType::oop_type());
- _register_finalizer = builder->make_function(
- (intptr_t) register_finalizer_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__register_finalizer");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- _safepoint = builder->make_function(
- (intptr_t) SafepointSynchronize::block,
- FunctionType::get(Type::VoidTy, params, false),
- "SafepointSynchronize__block");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(SharkType::intptr_type());
- params.push_back(SharkType::jint_type());
- params.push_back(SharkType::jint_type());
- _throw_ArrayIndexOutOfBoundsException = builder->make_function(
- (intptr_t) throw_ArrayIndexOutOfBoundsException_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__throw_ArrayIndexOutOfBoundsException");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(SharkType::intptr_type());
- params.push_back(SharkType::jint_type());
- _throw_NullPointerException = builder->make_function(
- (intptr_t) throw_NullPointerException_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__throw_NullPointerException");
-
- // Leaf calls
- params.clear();
- params.push_back(SharkType::jfloat_type());
- _f2i = builder->make_function(
- (intptr_t) SharedRuntime::f2i,
- FunctionType::get(SharkType::jint_type(), params, false),
- "SharedRuntime__f2i");
- _f2l = builder->make_function(
- (intptr_t) SharedRuntime::f2l,
- FunctionType::get(SharkType::jlong_type(), params, false),
- "SharedRuntime__f2l");
-
- params.clear();
- params.push_back(SharkType::jdouble_type());
- _d2i = builder->make_function(
- (intptr_t) SharedRuntime::d2i,
- FunctionType::get(SharkType::jint_type(), params, false),
- "SharedRuntime__d2i");
- _d2l = builder->make_function(
- (intptr_t) SharedRuntime::d2l,
- FunctionType::get(SharkType::jlong_type(), params, false),
- "SharedRuntime__d2l");
-
- // Non-VM calls
- params.clear();
- params.push_back(SharkType::intptr_type());
- params.push_back(SharkType::intptr_type());
- _dump = builder->make_function(
- (intptr_t) dump_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__dump");
-
- params.clear();
- params.push_back(SharkType::oop_type());
- params.push_back(SharkType::oop_type());
- assert(sizeof(bool) == 1, "fix this");
- _is_subtype_of = builder->make_function(
- (intptr_t) is_subtype_of_C,
- FunctionType::get(Type::Int8Ty, params, false),
- "SharkRuntime__is_subtype_of");
-
- params.clear();
- params.push_back(SharkType::intptr_type());
- params.push_back(SharkType::jint_type());
- _should_not_reach_here = builder->make_function(
- (intptr_t) report_should_not_reach_here,
- FunctionType::get(Type::VoidTy, params, false),
- "report_should_not_reach_here");
- _unimplemented = builder->make_function(
- (intptr_t) report_unimplemented,
- FunctionType::get(Type::VoidTy, params, false),
- "report_unimplemented");
-
- params.clear();
- params.push_back(SharkType::thread_type());
- params.push_back(SharkType::jint_type());
- _uncommon_trap = builder->make_function(
- (intptr_t) uncommon_trap_C,
- FunctionType::get(Type::VoidTy, params, false),
- "SharkRuntime__uncommon_trap");
-
- params.clear();
- _current_time_millis = builder->make_function(
- (intptr_t) os::javaTimeMillis,
- FunctionType::get(SharkType::jlong_type(), params, false),
- "os__javaTimeMillis");
-
- params.clear();
- params.push_back(SharkType::jdouble_type());
- _fabs = builder->make_function(
- (intptr_t) ::fabs,
- FunctionType::get(SharkType::jdouble_type(), params, false),
- "fabs");
- _tan = builder->make_function(
- (intptr_t) ::tan,
- FunctionType::get(SharkType::jdouble_type(), params, false),
- "tan");
- params.push_back(SharkType::jdouble_type());
- _atan2 = builder->make_function(
- (intptr_t) ::atan2,
- FunctionType::get(SharkType::jdouble_type(), params, false),
- "atan2");
-
- params.clear();
- params.push_back(SharkType::jlong_type());
- _unsafe_field_offset_to_byte_offset = builder->make_function(
- (intptr_t) Unsafe_field_offset_to_byte_offset,
- FunctionType::get(SharkType::jlong_type(), params, false),
- "Unsafe_field_offset_to_byte_offset");
-}
-
-JRT_ENTRY(int, SharkRuntime::find_exception_handler_C(JavaThread* thread,
- int* indexes,
- int num_indexes))
+JRT_ENTRY(int, SharkRuntime::find_exception_handler(JavaThread* thread,
+ int* indexes,
+ int num_indexes))
{
constantPoolHandle pool(thread, method(thread)->constants());
KlassHandle exc_klass(thread, ((oop) tos_at(thread, 0))->klass());
@@ -263,8 +50,8 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::monitorenter_C(JavaThread* thread,
- BasicObjectLock* lock))
+JRT_ENTRY(void, SharkRuntime::monitorenter(JavaThread* thread,
+ BasicObjectLock* lock))
{
if (PrintBiasedLockingStatistics)
Atomic::inc(BiasedLocking::slow_path_entry_count_addr());
@@ -281,8 +68,8 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::monitorexit_C(JavaThread* thread,
- BasicObjectLock* lock))
+JRT_ENTRY(void, SharkRuntime::monitorexit(JavaThread* thread,
+ BasicObjectLock* lock))
{
Handle object(thread, lock->obj());
assert(Universe::heap()->is_in_reserved_or_null(object()), "should be");
@@ -293,7 +80,7 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::new_instance_C(JavaThread* thread, int index))
+JRT_ENTRY(void, SharkRuntime::new_instance(JavaThread* thread, int index))
{
klassOop k_oop = method(thread)->constants()->klass_at(index, CHECK);
instanceKlassHandle klass(THREAD, k_oop);
@@ -323,18 +110,18 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::newarray_C(JavaThread* thread,
- BasicType type,
- int size))
+JRT_ENTRY(void, SharkRuntime::newarray(JavaThread* thread,
+ BasicType type,
+ int size))
{
oop obj = oopFactory::new_typeArray(type, size, CHECK);
thread->set_vm_result(obj);
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::anewarray_C(JavaThread* thread,
- int index,
- int size))
+JRT_ENTRY(void, SharkRuntime::anewarray(JavaThread* thread,
+ int index,
+ int size))
{
klassOop klass = method(thread)->constants()->klass_at(index, CHECK);
objArrayOop obj = oopFactory::new_objArray(klass, size, CHECK);
@@ -342,10 +129,10 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::multianewarray_C(JavaThread* thread,
- int index,
- int ndims,
- int* dims))
+JRT_ENTRY(void, SharkRuntime::multianewarray(JavaThread* thread,
+ int index,
+ int ndims,
+ int* dims))
{
klassOop klass = method(thread)->constants()->klass_at(index, CHECK);
oop obj = arrayKlass::cast(klass)->multi_allocate(ndims, dims, CHECK);
@@ -353,8 +140,8 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::register_finalizer_C(JavaThread* thread,
- oop object))
+JRT_ENTRY(void, SharkRuntime::register_finalizer(JavaThread* thread,
+ oop object))
{
assert(object->is_oop(), "should be");
assert(object->klass()->klass_part()->has_finalizer(), "should have");
@@ -362,7 +149,7 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::throw_ArrayIndexOutOfBoundsException_C(
+JRT_ENTRY(void, SharkRuntime::throw_ArrayIndexOutOfBoundsException(
JavaThread* thread,
const char* file,
int line,
@@ -377,9 +164,9 @@
}
JRT_END
-JRT_ENTRY(void, SharkRuntime::throw_NullPointerException_C(JavaThread* thread,
- const char* file,
- int line))
+JRT_ENTRY(void, SharkRuntime::throw_NullPointerException(JavaThread* thread,
+ const char* file,
+ int line))
{
Exceptions::_throw_msg(
thread, file, line,
@@ -391,7 +178,7 @@
// Non-VM calls
// Nothing in these must ever GC!
-void SharkRuntime::dump_C(const char *name, intptr_t value)
+void SharkRuntime::dump(const char *name, intptr_t value)
{
oop valueOop = (oop) value;
tty->print("%s = ", name);
@@ -404,12 +191,12 @@
tty->print_cr("");
}
-bool SharkRuntime::is_subtype_of_C(klassOop check_klass, klassOop object_klass)
+bool SharkRuntime::is_subtype_of(klassOop check_klass, klassOop object_klass)
{
return object_klass->klass_part()->is_subtype_of(check_klass);
}
-void SharkRuntime::uncommon_trap_C(JavaThread* thread, int trap_request)
+void SharkRuntime::uncommon_trap(JavaThread* thread, int trap_request)
{
// In C2, uncommon_trap_blob creates a frame, so all the various
// deoptimization functions expect to find the frame of the method
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkRuntime.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkRuntime.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkRuntime.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -24,94 +24,32 @@
*/
class SharkRuntime : public AllStatic {
+ // VM calls
public:
- static void initialize(SharkBuilder* builder);
+ static int find_exception_handler(JavaThread* thread,
+ int* indexes,
+ int num_indexes);
- // VM calls
- private:
- static llvm::Constant* _find_exception_handler;
- static llvm::Constant* _monitorenter;
- static llvm::Constant* _monitorexit;
- static llvm::Constant* _new_instance;
- static llvm::Constant* _newarray;
- static llvm::Constant* _anewarray;
- static llvm::Constant* _multianewarray;
- static llvm::Constant* _register_finalizer;
- static llvm::Constant* _safepoint;
- static llvm::Constant* _throw_ArrayIndexOutOfBoundsException;
- static llvm::Constant* _throw_NullPointerException;
+ static void monitorenter(JavaThread* thread, BasicObjectLock* lock);
+ static void monitorexit(JavaThread* thread, BasicObjectLock* lock);
- public:
- static llvm::Constant* find_exception_handler()
- {
- return _find_exception_handler;
- }
- static llvm::Constant* monitorenter()
- {
- return _monitorenter;
- }
- static llvm::Constant* monitorexit()
- {
- return _monitorexit;
- }
- static llvm::Constant* new_instance()
- {
- return _new_instance;
- }
- static llvm::Constant* newarray()
- {
- return _newarray;
- }
- static llvm::Constant* anewarray()
- {
- return _anewarray;
- }
- static llvm::Constant* multianewarray()
- {
- return _multianewarray;
- }
- static llvm::Constant* register_finalizer()
- {
- return _register_finalizer;
- }
- static llvm::Constant* safepoint()
- {
- return _safepoint;
- }
- static llvm::Constant* throw_ArrayIndexOutOfBoundsException()
- {
- return _throw_ArrayIndexOutOfBoundsException;
- }
- static llvm::Constant* throw_NullPointerException()
- {
- return _throw_NullPointerException;
- }
+ static void new_instance(JavaThread* thread, int index);
+ static void newarray(JavaThread* thread, BasicType type, int size);
+ static void anewarray(JavaThread* thread, int index, int size);
+ static void multianewarray(JavaThread* thread,
+ int index,
+ int ndims,
+ int* dims);
- private:
- static int find_exception_handler_C(JavaThread* thread,
- int* indexes,
- int num_indexes);
+ static void register_finalizer(JavaThread* thread, oop object);
- static void monitorenter_C(JavaThread* thread, BasicObjectLock* lock);
- static void monitorexit_C(JavaThread* thread, BasicObjectLock* lock);
-
- static void new_instance_C(JavaThread* thread, int index);
- static void newarray_C(JavaThread* thread, BasicType type, int size);
- static void anewarray_C(JavaThread* thread, int index, int size);
- static void multianewarray_C(JavaThread* thread,
- int index,
- int ndims,
- int* dims);
-
- static void register_finalizer_C(JavaThread* thread, oop object);
-
- static void throw_ArrayIndexOutOfBoundsException_C(JavaThread* thread,
- const char* file,
- int line,
- int index);
- static void throw_NullPointerException_C(JavaThread* thread,
- const char* file,
- int line);
+ static void throw_ArrayIndexOutOfBoundsException(JavaThread* thread,
+ const char* file,
+ int line,
+ int index);
+ static void throw_NullPointerException(JavaThread* thread,
+ const char* file,
+ int line);
// Helpers for VM calls
private:
@@ -136,88 +74,9 @@
return *(thread->zero_stack()->sp() + offset);
}
- // Leaf calls
- private:
- static llvm::Constant* _f2i;
- static llvm::Constant* _f2l;
- static llvm::Constant* _d2i;
- static llvm::Constant* _d2l;
-
+ // Non-VM calls
public:
- static llvm::Constant* f2i()
- {
- return _f2i;
- }
- static llvm::Constant* f2l()
- {
- return _f2l;
- }
- static llvm::Constant* d2i()
- {
- return _d2i;
- }
- static llvm::Constant* d2l()
- {
- return _d2l;
- }
-
- // Non-VM calls
- private:
- static llvm::Constant* _dump;
- static llvm::Constant* _is_subtype_of;
- static llvm::Constant* _should_not_reach_here;
- static llvm::Constant* _unimplemented;
- static llvm::Constant* _uncommon_trap;
- static llvm::Constant* _current_time_millis;
- static llvm::Constant* _fabs;
- static llvm::Constant* _tan;
- static llvm::Constant* _atan2;
- static llvm::Constant* _unsafe_field_offset_to_byte_offset;
-
- public:
- static llvm::Constant* dump()
- {
- return _dump;
- }
- static llvm::Constant* is_subtype_of()
- {
- return _is_subtype_of;
- }
- static llvm::Constant* should_not_reach_here()
- {
- return _should_not_reach_here;
- }
- static llvm::Constant* unimplemented()
- {
- return _unimplemented;
- }
- static llvm::Constant* uncommon_trap()
- {
- return _uncommon_trap;
- }
- static llvm::Constant* current_time_millis()
- {
- return _current_time_millis;
- }
- static llvm::Constant* fabs()
- {
- return _fabs;
- }
- static llvm::Constant* tan()
- {
- return _tan;
- }
- static llvm::Constant* atan2()
- {
- return _atan2;
- }
- static llvm::Constant* unsafe_field_offset_to_byte_offset()
- {
- return _unsafe_field_offset_to_byte_offset;
- }
-
- private:
- static void dump_C(const char *name, intptr_t value);
- static bool is_subtype_of_C(klassOop check_klass, klassOop object_klass);
- static void uncommon_trap_C(JavaThread* thread, int trap_request);
+ static void dump(const char *name, intptr_t value);
+ static bool is_subtype_of(klassOop check_klass, klassOop object_klass);
+ static void uncommon_trap(JavaThread* thread, int trap_request);
};
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp Thu Jul 30 04:51:32 2009 -0400
@@ -324,8 +324,10 @@
builder()->SetInsertPoint(zero_block);
if (value->is_jobject()) {
call_vm(
- SharkRuntime::throw_NullPointerException(),
- builder()->pointer_constant(__FILE__),
+ builder()->throw_NullPointerException(),
+ builder()->CreateIntToPtr(
+ LLVMValue::intptr_constant((intptr_t) __FILE__),
+ PointerType::getUnqual(SharkType::jbyte_type())),
LLVMValue::jint_constant(__LINE__),
EX_CHECK_NONE);
}
@@ -349,8 +351,10 @@
builder()->SetInsertPoint(out_of_bounds);
SharkState *saved_state = current_state()->copy();
call_vm(
- SharkRuntime::throw_ArrayIndexOutOfBoundsException(),
- builder()->pointer_constant(__FILE__),
+ builder()->throw_ArrayIndexOutOfBoundsException(),
+ builder()->CreateIntToPtr(
+ LLVMValue::intptr_constant((intptr_t) __FILE__),
+ PointerType::getUnqual(SharkType::jbyte_type())),
LLVMValue::jint_constant(__LINE__),
index->jint_value(),
EX_CHECK_NONE);
@@ -433,7 +437,7 @@
builder()->CreateStructGEP(options, i));
Value *index = call_vm(
- SharkRuntime::find_exception_handler(),
+ builder()->find_exception_handler(),
builder()->CreateStructGEP(options, 0),
LLVMValue::jint_constant(num_options),
EX_CHECK_NO_CATCH);
@@ -483,7 +487,8 @@
Value *state = builder()->CreateLoad(
builder()->CreateIntToPtr(
- builder()->pointer_constant(SafepointSynchronize::address_of_state()),
+ LLVMValue::intptr_constant(
+ (intptr_t) SafepointSynchronize::address_of_state()),
PointerType::getUnqual(SharkType::jint_type())),
"state");
@@ -494,7 +499,7 @@
do_safepoint, safepointed);
builder()->SetInsertPoint(do_safepoint);
- call_vm(SharkRuntime::safepoint(), EX_CHECK_FULL);
+ call_vm(builder()->safepoint(), EX_CHECK_FULL);
BasicBlock *safepointed_block = builder()->GetInsertBlock();
builder()->CreateBr(safepointed);
@@ -553,7 +558,7 @@
{
decache_for_trap();
builder()->CreateCall2(
- SharkRuntime::uncommon_trap(),
+ builder()->uncommon_trap(),
thread(),
LLVMValue::jint_constant(trap_request));
builder()->CreateRetVoid();
@@ -594,7 +599,7 @@
do_call, done);
builder()->SetInsertPoint(do_call);
- call_vm(SharkRuntime::register_finalizer(), receiver, EX_CHECK_FULL);
+ call_vm(builder()->register_finalizer(), receiver, EX_CHECK_FULL);
BasicBlock *branch_block = builder()->GetInsertBlock();
builder()->CreateBr(done);
@@ -989,16 +994,19 @@
builder()->CreateIntCast(vtable_length, SharkType::intptr_type(), false);
bool needs_aligning = HeapWordsPerLong > 1;
- const char *itable_start_name = "itable_start";
Value *itable_start = builder()->CreateAdd(
vtable_start,
builder()->CreateShl(
vtable_length,
LLVMValue::intptr_constant(exact_log2(vtableEntry::size() * wordSize))),
- needs_aligning ? "" : itable_start_name);
- if (needs_aligning)
- itable_start = builder()->CreateAlign(
- itable_start, BytesPerLong, itable_start_name);
+ needs_aligning ? "" : "itable_start");
+ if (needs_aligning) {
+ itable_start = builder()->CreateAnd(
+ builder()->CreateAdd(
+ itable_start, LLVMValue::intptr_constant(BytesPerLong - 1)),
+ LLVMValue::intptr_constant(~(BytesPerLong - 1)),
+ "itable_start");
+ }
// Locate this interface's entry in the table
Value *iklass = builder()->CreateInlineOop(method->holder());
@@ -1327,7 +1335,7 @@
builder()->CreateCondBr(
builder()->CreateICmpNE(
builder()->CreateCall2(
- SharkRuntime::is_subtype_of(), check_klass, object_klass),
+ builder()->is_subtype_of(), check_klass, object_klass),
LLVMValue::jbyte_constant(0)),
is_instance, not_instance);
@@ -1483,13 +1491,13 @@
// Heap allocation
Value *top_addr = builder()->CreateIntToPtr(
- builder()->pointer_constant(Universe::heap()->top_addr()),
+ LLVMValue::intptr_constant((intptr_t) Universe::heap()->top_addr()),
PointerType::getUnqual(SharkType::intptr_type()),
"top_addr");
Value *end = builder()->CreateLoad(
builder()->CreateIntToPtr(
- builder()->pointer_constant(Universe::heap()->end_addr()),
+ LLVMValue::intptr_constant((intptr_t) Universe::heap()->end_addr()),
PointerType::getUnqual(SharkType::intptr_type())),
"end");
@@ -1565,7 +1573,7 @@
// The slow path
call_vm(
- SharkRuntime::new_instance(),
+ builder()->new_instance(),
LLVMValue::jint_constant(iter()->get_klass_index()),
EX_CHECK_FULL);
slow_object = function()->CreateGetVMResult();
@@ -1595,7 +1603,7 @@
BasicType type = (BasicType) iter()->get_index();
call_vm(
- SharkRuntime::newarray(),
+ builder()->newarray(),
LLVMValue::jint_constant(type),
pop()->jint_value(),
EX_CHECK_FULL);
@@ -1618,7 +1626,7 @@
}
call_vm(
- SharkRuntime::anewarray(),
+ builder()->anewarray(),
LLVMValue::jint_constant(iter()->get_klass_index()),
pop()->jint_value(),
EX_CHECK_FULL);
@@ -1650,7 +1658,7 @@
}
call_vm(
- SharkRuntime::multianewarray(),
+ builder()->multianewarray(),
LLVMValue::jint_constant(iter()->get_klass_index()),
LLVMValue::jint_constant(ndims),
builder()->CreateStructGEP(dimensions, 0),
@@ -1764,7 +1772,7 @@
// It's not a recursive case so we need to drop into the runtime
builder()->SetInsertPoint(not_recursive);
call_vm(
- SharkRuntime::monitorenter(), monitor_addr,
+ builder()->monitorenter(), monitor_addr,
exception_action | EAM_MONITOR_FUDGE);
BasicBlock *acquired_slow = builder()->GetInsertBlock();
builder()->CreateBr(lock_acquired);
@@ -1817,7 +1825,7 @@
// Need to drop into the runtime to release this one
builder()->SetInsertPoint(slow_path);
- call_vm(SharkRuntime::monitorexit(), monitor_addr, exception_action);
+ call_vm(builder()->monitorexit(), monitor_addr, exception_action);
BasicBlock *released_slow = builder()->GetInsertBlock();
builder()->CreateBr(lock_released);
diff -r ff01867e1a2a -r 051ca564791d ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp Wed Jul 29 10:57:38 2009 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp Thu Jul 30 04:51:32 2009 -0400
@@ -256,10 +256,10 @@
// VM calls
private:
- llvm::CallInst* call_vm(llvm::Constant* callee,
- llvm::Value** args_start,
- llvm::Value** args_end,
- int exception_action)
+ llvm::CallInst* call_vm(llvm::Value* callee,
+ llvm::Value** args_start,
+ llvm::Value** args_end,
+ int exception_action)
{
decache_for_VM_call();
function()->set_last_Java_frame();
@@ -274,32 +274,32 @@
}
public:
- llvm::CallInst* call_vm(llvm::Constant* callee,
- int exception_action)
+ llvm::CallInst* call_vm(llvm::Value* callee,
+ int exception_action)
{
llvm::Value *args[] = {thread()};
return call_vm(callee, args, args + 1, exception_action);
}
- llvm::CallInst* call_vm(llvm::Constant* callee,
- llvm::Value* arg1,
- int exception_action)
+ llvm::CallInst* call_vm(llvm::Value* callee,
+ llvm::Value* arg1,
+ int exception_action)
{
llvm::Value *args[] = {thread(), arg1};
return call_vm(callee, args, args + 2, exception_action);
}
- llvm::CallInst* call_vm(llvm::Constant* callee,
- llvm::Value* arg1,
- llvm::Value* arg2,
- int exception_action)
+ llvm::CallInst* call_vm(llvm::Value* callee,
+ llvm::Value* arg1,
+ llvm::Value* arg2,
+ int exception_action)
{
llvm::Value *args[] = {thread(), arg1, arg2};
return call_vm(callee, args, args + 3, exception_action);
}
- llvm::CallInst* call_vm(llvm::Constant* callee,
- llvm::Value* arg1,
- llvm::Value* arg2,
- llvm::Value* arg3,
- int exception_action)
+ llvm::CallInst* call_vm(llvm::Value* callee,
+ llvm::Value* arg1,
+ llvm::Value* arg2,
+ llvm::Value* arg3,
+ int exception_action)
{
llvm::Value *args[] = {thread(), arg1, arg2, arg3};
return call_vm(callee, args, args + 4, exception_action);
More information about the distro-pkg-dev
mailing list