Big Shark refactoring
Gary Benson
gbenson at redhat.com
Thu Jun 18 09:12:39 PDT 2009
Hi all,
There's a lot of information that needs passing around during a Shark
compilation, and previously this has been done in a pretty ad-hoc way.
This commit rationalizes this, by creating two new classes which wrap
all compilation- and method-specific data. Classes requiring this
data can then extend one or the other of these classes to get all the
information they need.
Cheers,
Gary
--
http://gbenson.net/
-------------- next part --------------
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ChangeLog
--- a/ChangeLog Thu Jun 18 10:58:02 2009 +0200
+++ b/ChangeLog Thu Jun 18 12:00:59 2009 -0400
@@ -1,3 +1,156 @@
+2009-06-18 Gary Benson <gbenson at redhat.com>
+
+ * ports/hotspot/src/share/vm/shark/sharkInvariants.hpp: New file.
+ * ports/hotspot/src/share/vm/shark/sharkInvariants.cpp: Likewise.
+
+ * ports/hotspot/src/share/vm/shark/sharkFunction.hpp
+ (SharkFunction): Made a subclass of SharkTargetInvariants.
+ (SharkFunction::SharkFunction): Updated constructor.
+ (SharkFunction::_compiler): Removed.
+ (SharkFunction::_flow): Likewise.
+ (SharkFunction::_iter): Likewise.
+ (SharkFunction::_thread): Likewise.
+ (SharkFunction::_max_monitors): Likewise.
+ (SharkFunction::compiler): Likewise.
+ (SharkFunction::flow): Likewise.
+ (SharkFunction::iter): Likewise.
+ (SharkFunction::thread): Likewise.
+ (SharkFunction::max_monitors): Likewise.
+ (SharkFunction::builder): Likewise.
+ (SharkFunction::arg_size): Likewise.
+ (SharkFunction::debug_info): Likewise.
+ (SharkFunction::env): Likewise.
+ (SharkFunction::max_locals): Likewise.
+ (SharkFunction::max_stack): Likewise.
+ (SharkFunction::target): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkFunction.hpp
+ (SharkFunction::initialize): Updated.
+
+ * ports/hotspot/src/share/vm/shark/sharkBlock.hpp
+ (SharkBlock): Made a subclass of SharkTargetInvariants.
+ (SharkBlock::SharkBlock): Updated constructors.
+ (SharkBlock::_builder): Removed.
+ (SharkBlock::_target): Likewise.
+ (SharkBlock::_thread): Likewise.
+ (SharkBlock::builder): Likewise.
+ (SharkBlock::target): Likewise.
+ (SharkBlock::thread): Likewise.
+ (SharkBlock::max_locals): Likewise.
+ (SharkBlock::max_stack): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkBlock.cpp
+ (SharkBlock::initial_current_state): Use SharkState::copy.
+
+ * ports/hotspot/src/share/vm/shark/sharkState.hpp
+ (SharkState): Made a subclass of SharkTargetInvariants.
+ (SharkState::SharkState): Updated constructors.
+ (SharkState::_block): Removed.
+ (SharkState::_function): Likewise.
+ (SharkState::block): Likewise.
+ (SharkState::function): Likewise.
+ (SharkState::builder): Likewise.
+ (SharkState::max_locals): Likewise.
+ (SharkState::max_stack): Likewise.
+ (SharkState::max_monitors): Likewise.
+ (SharkState::pop): Likewise.
+ (SharkState::copy): Updated.
+ (SharkState::decache_for_Java_call): Moved to SharkTopLevelBlock.
+ (SharkState::cache_after_Java_call): Likewise.
+ (SharkState::decache_for_VM_call): Likewise.
+ (SharkState::cache_after_VM_call): Likewise.
+ (SharkState::decache_for_trap): Likewise.
+ (SharkPHIState::_block): New field.
+ (SharkPHIState::block): New method.
+ * ports/hotspot/src/share/vm/shark/sharkState.inline.hpp: Removed.
+ * ports/hotspot/src/share/vm/shark/sharkState.cpp
+ (SharkState::equal_to): Updated.
+ (SharkState::decache_for_Java_call): Moved to SharkTopLevelBlock.
+ (SharkState::cache_after_Java_call): Likewise.
+ (SharkState::decache_for_VM_call): Likewise.
+ (SharkState::cache_after_VM_call): Likewise.
+ (SharkState::decache_for_trap): Likewise.
+ (SharkEntryState::SharkEntryState): Updated.
+ (SharkPHIState::SharkPHIState): Likewise.
+ (SharkPHIState::add_incoming): Likewise.
+
+ * ports/hotspot/src/share/vm/shark/sharkStateScanner.hpp
+ (SharkStateScanner): Made a subclass of SharkTargetInvariants.
+ (SharkStateScanner::SharkStateScanner): Updated constructor.
+ (SharkStateScanner::start_stack): Updated arguments.
+ (SharkStateScanner::start_locals): Likewise.
+ (SharkStateScanner::stack_integrity_checks): Made non-static.
+ (SharkStateScanner::locals_integrity_checks): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkStateScanner.cpp
+ (SharkStateScanner::scan): Updated.
+ (SharkStateScanner::locals_integrity_checks): Likewise.
+
+ * ports/hotspot/src/share/vm/shark/sharkCacheDecache.hpp
+ (SharkCacherDecacher::builder): Removed.
+ (SharkDecacher::debug_info): Likewise.
+ (SharkDecacher::start_stack): Updated arguments.
+ (SharkDecacher::start_locals): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp
+ (SharkDecacher::start_frame): Updated.
+ (SharkDecacher::start_stack): Likewise..
+ (SharkDecacher::start_locals): Likewise.
+ (SharkDecacher::end_frame): Likewise.
+
+ * ports/hotspot/src/share/vm/shark/sharkInliner.hpp
+ (SharkInliner::attempt_inline): Removed thread argument.
+ * ports/hotspot/src/share/vm/shark/sharkInliner.cpp
+ (SharkInlineBlock): Made a subclass of SharkTargetInvariants.
+ (SharkInlineBlock::SharkInlineBlock): Updated constructor.
+ (SharkInlinerHelper::SharkInlinerHelper): Likewise.
+ (SharkInlinerHelper::_thread): Removed.
+ (SharkInlinerHelper::thread): Likewise.
+ (SharkInlinerHelper::do_inline): Updated.
+ (SharkInliner::attempt_inline): Updated.
+
+ * ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp
+ (SharkIntrinsics): Made a subclass of SharkTargetInvariants.
+ (SharkIntrinsics::inline_intrinsic): Updated arguments.
+ (SharkIntrinsics::SharkIntrinsics): New method.
+ (SharkIntrinsics::_state): New field.
+ (SharkIntrinsics::state): New method.
+ (SharkIntrinsics::do_intrinsic): Likewise.
+ (SharkIntrinsics::do_Math_minmax): Updated arguments.
+ (SharkIntrinsics::do_Math_1to1): Likewise.
+ (SharkIntrinsics::do_Math_2to1): Likewise.
+ (SharkIntrinsics::do_Object_getClass): Likewise.
+ (SharkIntrinsics::do_System_currentTimeMillis): Likewise.
+ (SharkIntrinsics::do_Thread_currentThread): Likewise.
+ (SharkIntrinsics::do_Unsafe_compareAndSwapInt): Likewise.
+ * ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp
+ (SharkIntrinsics::inline_intrinsic): Updated.
+ (SharkIntrinsics::do_intrinsic): New method.
+ (SharkIntrinsics::do_Math_minmax): Updated.
+ (SharkIntrinsics::do_Math_1to1): Likewise.
+ (SharkIntrinsics::do_Math_2to1): Likewise.
+ (SharkIntrinsics::do_Object_getClass): Likewise.
+ (SharkIntrinsics::do_System_currentTimeMillis): Likewise.
+ (SharkIntrinsics::do_Thread_currentThread): Likewise.
+ (SharkIntrinsics::do_Unsafe_compareAndSwapInt): Likewise.
+
+ * ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp
+ (SharkTopLevelBlock::SharkTopLevelBlock): Updated constructor.
+ (SharkTopLevelBlock::decache_for_Java_call): Moved from SharkState.
+ (SharkTopLevelBlock::cache_after_Java_call): Likewise.
+ (SharkTopLevelBlock::decache_for_VM_call): Likewise.
+ (SharkTopLevelBlock::cache_after_VM_call): Likewise.
+ (SharkTopLevelBlock::decache_for_trap): Likewise.
+ (SharkTopLevelBlock::call_vm): Updated.
+ * ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp
+ (SharkTopLevelBlock::decache_for_Java_call): Moved from SharkState.
+ (SharkTopLevelBlock::cache_after_Java_call): Likewise.
+ (SharkTopLevelBlock::decache_for_VM_call): Likewise.
+ (SharkTopLevelBlock::cache_after_VM_call): Likewise.
+ (SharkTopLevelBlock::decache_for_trap): Likewise.
+ (SharkTopLevelBlock::do_trap): Updated.
+ (SharkTopLevelBlock::improve_virtual_call): Likewise.
+ (SharkTopLevelBlock::do_call): Likewise.
+ (SharkTopLevelBlock::acquire_lock): Likewise.
+
+ * ports/hotspot/src/share/vm/includeDB_shark: Updated.
+
2009-06-18 Mark Wielaard <mark at klomp.org>
* rt/net/sourceforge/jnlp/services/XExtendedService.java
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/includeDB_shark
--- a/ports/hotspot/src/share/vm/includeDB_shark Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/includeDB_shark Thu Jun 18 12:00:59 2009 -0400
@@ -50,8 +50,6 @@
compileBroker.cpp sharkCompiler.hpp
-disassembler_<arch>.cpp sharkEntry.hpp
-
globals.hpp shark_globals_<arch>.hpp
globals.cpp shark_globals.hpp
@@ -75,7 +73,7 @@
sharkBlock.cpp sharkBuilder.hpp
sharkBlock.cpp sharkConstant.hpp
sharkBlock.cpp sharkRuntime.hpp
-sharkBlock.cpp sharkState.inline.hpp
+sharkBlock.cpp sharkState.hpp
sharkBlock.cpp sharkValue.hpp
sharkBlock.hpp allocation.hpp
@@ -85,6 +83,7 @@
sharkBlock.hpp llvmHeaders.hpp
sharkBlock.hpp sharkBuilder.hpp
sharkBlock.hpp sharkConstant.hpp
+sharkBlock.hpp sharkInvariants.hpp
sharkBlock.hpp sharkState.hpp
sharkBlock.hpp sharkValue.hpp
@@ -121,7 +120,7 @@
sharkCacheDecache.cpp sharkBuilder.hpp
sharkCacheDecache.cpp sharkCacheDecache.hpp
sharkCacheDecache.cpp sharkFunction.hpp
-sharkCacheDecache.cpp sharkState.inline.hpp
+sharkCacheDecache.cpp sharkState.hpp
sharkCacheDecache.hpp ciMethod.hpp
sharkCacheDecache.hpp debugInfoRec.hpp
@@ -181,7 +180,7 @@
sharkFunction.cpp sharkBuilder.hpp
sharkFunction.cpp sharkEntry.hpp
sharkFunction.cpp sharkFunction.hpp
-sharkFunction.cpp sharkState.inline.hpp
+sharkFunction.cpp sharkState.hpp
sharkFunction.cpp sharkTopLevelBlock.hpp
sharkFunction.hpp allocation.hpp
@@ -191,6 +190,7 @@
sharkFunction.hpp llvmHeaders.hpp
sharkFunction.hpp llvmValue.hpp
sharkFunction.hpp sharkBuilder.hpp
+sharkFunction.hpp sharkInvariants.hpp
sharkInliner.cpp allocation.hpp
sharkInliner.cpp bytecodes.hpp
@@ -198,29 +198,44 @@
sharkInliner.cpp ciMethod.hpp
sharkInliner.cpp ciStreams.hpp
sharkInliner.cpp shark_globals.hpp
+sharkInliner.cpp sharkBlock.hpp
sharkInliner.cpp sharkConstant.hpp
sharkInliner.cpp sharkInliner.hpp
sharkInliner.cpp sharkIntrinsics.hpp
-sharkInliner.cpp sharkState.inline.hpp
+sharkInliner.cpp sharkState.hpp
sharkInliner.cpp sharkValue.hpp
sharkInliner.hpp allocation.hpp
sharkInliner.hpp ciMethod.hpp
sharkInliner.hpp llvmHeaders.hpp
-sharkInliner.hpp sharkState.inline.hpp
+sharkInliner.hpp sharkState.hpp
sharkIntrinsics.cpp ciMethod.hpp
sharkIntrinsics.cpp llvmHeaders.hpp
sharkIntrinsics.cpp shark_globals.hpp
sharkIntrinsics.cpp sharkIntrinsics.hpp
sharkIntrinsics.cpp sharkRuntime.hpp
-sharkIntrinsics.cpp sharkState.inline.hpp
+sharkIntrinsics.cpp sharkState.hpp
sharkIntrinsics.cpp sharkValue.hpp
sharkIntrinsics.hpp allocation.hpp
sharkIntrinsics.hpp ciMethod.hpp
sharkIntrinsics.hpp llvmHeaders.hpp
sharkIntrinsics.hpp sharkState.hpp
+
+sharkInvariants.cpp sharkInvariants.hpp
+
+sharkInvariants.hpp allocation.hpp
+sharkInvariants.hpp ciEnv.hpp
+sharkInvariants.hpp ciMethod.hpp
+sharkInvariants.hpp ciInstanceKlass.hpp
+sharkInvariants.hpp ciTypeFlow.hpp
+sharkInvariants.hpp debugInfoRec.hpp
+sharkInvariants.hpp dependencies.hpp
+sharkInvariants.hpp llvmHeaders.hpp
+sharkInvariants.hpp sharkBuilder.hpp
+sharkInvariants.hpp sharkCompiler.hpp
+sharkInvariants.hpp sharkMemoryManager.hpp
sharkMemoryManager.hpp llvmHeaders.hpp
sharkMemoryManager.hpp sharkEntry.hpp
@@ -249,7 +264,7 @@
sharkState.cpp ciTypeFlow.hpp
sharkState.cpp sharkBuilder.hpp
sharkState.cpp sharkCacheDecache.hpp
-sharkState.cpp sharkState.inline.hpp
+sharkState.cpp sharkState.hpp
sharkState.cpp sharkTopLevelBlock.hpp
sharkState.cpp sharkType.hpp
sharkState.cpp sharkValue.hpp
@@ -258,19 +273,16 @@
sharkState.hpp ciMethod.hpp
sharkState.hpp llvmHeaders.hpp
sharkState.hpp sharkBuilder.hpp
+sharkState.hpp sharkInvariants.hpp
sharkState.hpp sharkValue.hpp
-sharkState.inline.hpp sharkBlock.hpp
-sharkState.inline.hpp sharkBuilder.hpp
-sharkState.inline.hpp sharkFunction.hpp
-sharkState.inline.hpp sharkState.hpp
-
-sharkStateScanner.cpp sharkState.inline.hpp
+sharkStateScanner.cpp sharkState.hpp
sharkStateScanner.cpp sharkStateScanner.hpp
sharkStateScanner.hpp allocation.hpp
sharkStateScanner.hpp llvmHeaders.hpp
sharkStateScanner.hpp sharkFunction.hpp
+sharkStateScanner.hpp sharkInvariants.hpp
sharkTopLevelBlock.cpp allocation.hpp
sharkTopLevelBlock.cpp bytecodes.hpp
@@ -283,12 +295,13 @@
sharkTopLevelBlock.cpp llvmHeaders.hpp
sharkTopLevelBlock.cpp llvmValue.hpp
sharkTopLevelBlock.cpp shark_globals.hpp
+sharkTopLevelBlock.cpp sharkCacheDecache.hpp
sharkTopLevelBlock.cpp sharkTopLevelBlock.hpp
sharkTopLevelBlock.cpp sharkBuilder.hpp
sharkTopLevelBlock.cpp sharkConstant.hpp
sharkTopLevelBlock.cpp sharkInliner.hpp
sharkTopLevelBlock.cpp sharkRuntime.hpp
-sharkTopLevelBlock.cpp sharkState.inline.hpp
+sharkTopLevelBlock.cpp sharkState.hpp
sharkTopLevelBlock.cpp sharkValue.hpp
sharkTopLevelBlock.hpp allocation.hpp
@@ -300,7 +313,7 @@
sharkTopLevelBlock.hpp sharkBlock.hpp
sharkTopLevelBlock.hpp sharkBuilder.hpp
sharkTopLevelBlock.hpp sharkFunction.hpp
-sharkTopLevelBlock.hpp sharkState.inline.hpp
+sharkTopLevelBlock.hpp sharkState.hpp
sharkTopLevelBlock.hpp sharkValue.hpp
sharkType.cpp arrayOop.hpp
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkBlock.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkBlock.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkBlock.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -888,7 +888,7 @@
SharkState* SharkBlock::initial_current_state()
{
- return new SharkState(this, entry_state());
+ return entry_state()->copy();
}
int SharkBlock::switch_default_dest()
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkBlock.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkBlock.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkBlock.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -25,61 +25,32 @@
class SharkState;
-class SharkBlock : public ResourceObj {
- public:
- SharkBlock(SharkBuilder* builder,
- ciMethod* target,
- ciBytecodeStream* iter,
- llvm::Value* thread)
- : _builder(builder),
- _target(target),
- _iter(iter),
- _current_state(NULL),
- _thread(thread) {}
+class SharkBlock : public SharkTargetInvariants {
+ protected:
+ SharkBlock(const SharkTargetInvariants* parent)
+ : SharkTargetInvariants(parent),
+ _iter(target()),
+ _current_state(NULL) {}
+
+ SharkBlock(const SharkCompileInvariants* parent, ciMethod* target)
+ : SharkTargetInvariants(parent, target),
+ _iter(target),
+ _current_state(NULL) {}
private:
- SharkBuilder* _builder;
- ciMethod* _target;
- ciBytecodeStream* _iter;
- SharkState* _current_state;
- llvm::Value* _thread;
+ ciBytecodeStream _iter;
+ SharkState* _current_state;
public:
- SharkBuilder* builder() const
+ ciBytecodeStream* iter()
{
- return _builder;
+ return &_iter;
}
- ciMethod* target() const
- {
- return _target;
- }
- ciBytecodeStream* iter() const
- {
- return _iter;
- }
- llvm::Value* thread() const
- {
- return _thread;
- }
-
- // Target properties
- public:
- int max_locals() const
- {
- return target()->max_locals();
- }
- int max_stack() const
- {
- return target()->max_stack();
- }
-
- // Bytecode stream
- public:
- Bytecodes::Code bc() const
+ Bytecodes::Code bc()
{
return iter()->cur_bc();
}
- int bci() const
+ int bci()
{
return iter()->cur_bci();
}
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -34,20 +34,20 @@
_pc_offset = builder()->code_buffer()->create_unique_offset();
_oopmap = new OopMap(
oopmap_slot_munge(function()->oopmap_frame_size()),
- oopmap_slot_munge(function()->arg_size()));
+ oopmap_slot_munge(arg_size()));
debug_info()->add_safepoint(pc_offset(), oopmap());
}
-void SharkDecacher::start_stack(int num_slots, int max_slots)
+void SharkDecacher::start_stack(int stack_depth)
{
// Create the array we'll record our stack slots in
- _exparray = new GrowableArray<ScopeValue*>(num_slots);
+ _exparray = new GrowableArray<ScopeValue*>(stack_depth);
// Set the stack pointer
function()->CreateStoreZeroStackPointer(
builder()->CreatePtrToInt(
function()->CreateAddressOfFrameEntry(
- function()->stack_slots_offset() + max_slots - num_slots),
+ function()->stack_slots_offset() + max_stack() - stack_depth),
SharkType::intptr_type()));
}
@@ -123,10 +123,10 @@
function()->CreateAddressOfFrameEntry(offset));
}
-void SharkDecacher::start_locals(int num_locals)
+void SharkDecacher::start_locals()
{
// Create the array we'll record our local variables in
- _locarray = new GrowableArray<ScopeValue*>(num_locals);}
+ _locarray = new GrowableArray<ScopeValue*>(max_locals());}
void SharkDecacher::process_local_slot(int index,
SharkValue** addr,
@@ -158,7 +158,7 @@
// Record the scope
debug_info()->describe_scope(
pc_offset(),
- function()->target(),
+ target(),
bci(),
debug_info()->create_scope_values(locarray()),
debug_info()->create_scope_values(exparray()),
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkCacheDecache.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkCacheDecache.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkCacheDecache.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -40,12 +40,6 @@
SharkCacherDecacher(SharkFunction* function)
: SharkStateScanner(function) {}
- protected:
- SharkBuilder* builder() const
- {
- return function()->builder();
- }
-
// Helper
protected:
static int adjusted_offset(SharkValue* value, int offset)
@@ -68,12 +62,6 @@
int bci() const
{
return _bci;
- }
-
- private:
- DebugInformationRecorder* debug_info() const
- {
- return function()->debug_info();
}
private:
@@ -109,7 +97,7 @@
protected:
void start_frame();
- void start_stack(int num_slots, int max_slots);
+ void start_stack(int stack_depth);
void process_stack_slot(int index, SharkValue** value, int offset);
void start_monitors(int num_monitors);
@@ -119,7 +107,7 @@
void process_method_slot(llvm::Value** value, int offset);
void process_pc_slot(int offset);
- void start_locals(int num_locals);
+ void start_locals();
void process_local_slot(int index, SharkValue** value, int offset);
void end_frame();
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkCompiler.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkCompiler.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkCompiler.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -120,8 +120,7 @@
builder()->set_code_buffer(&cb);
// Compile the method
- ciBytecodeStream iter(target);
- SharkFunction function(this, name, flow, &iter);
+ SharkFunction function(this, env, flow, name);
// Unhook the code buffer
builder()->set_code_buffer(NULL);
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkFunction.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkFunction.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkFunction.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -39,7 +39,7 @@
// Create the function
_function = builder()->CreateFunction(name());
entry->set_llvm_function(function());
- compiler()->memory_manager()->set_entry_for_function(function(), entry);
+ memory_manager()->set_entry_for_function(function(), entry);
// Get our arguments
Function::arg_iterator ai = function()->arg_begin();
@@ -48,12 +48,13 @@
Argument *base_pc = ai++;
base_pc->setName("base_pc");
builder()->code_buffer()->set_base_pc(base_pc);
- _thread = ai++;
- _thread->setName("thread");
+ Argument *thread = ai++;
+ thread->setName("thread");
+ set_thread(thread);
// Create the list of blocks
set_block_insertion_point(NULL);
- _blocks = NEW_RESOURCE_ARRAY(SharkTopLevelBlock*, flow()->block_count());
+ _blocks = NEW_RESOURCE_ARRAY(SharkTopLevelBlock*, block_count());
for (int i = 0; i < block_count(); i++) {
ciTypeFlow::Block *b = flow()->pre_order_at(i);
@@ -76,14 +77,6 @@
block(i)->initialize();
}
- // Initialize the monitors
- _max_monitors = 0;
- if (target()->is_synchronized() || target()->uses_monitors()) {
- for (int i = 0; i < block_count(); i++)
- _max_monitors = MAX2(
- _max_monitors, block(i)->ciblock()->monitor_count());
- }
-
// Create the method preamble
set_block_insertion_point(&function()->front());
builder()->SetInsertPoint(CreateBlock());
@@ -98,7 +91,7 @@
// Lock if necessary
SharkState *entry_state = new SharkEntryState(start_block, method);
- if (target()->is_synchronized()) {
+ if (is_synchronized()) {
SharkTopLevelBlock *locker =
new SharkTopLevelBlock(this, start_block->ciblock());
locker->add_incoming(entry_state);
@@ -291,10 +284,11 @@
return result;
}
-class DeferredZeroCheck : public ResourceObj {
+class DeferredZeroCheck : public SharkTargetInvariants {
public:
DeferredZeroCheck(SharkTopLevelBlock* block, SharkValue* value)
- : _block(block),
+ : SharkTargetInvariants(block),
+ _block(block),
_value(value),
_bci(block->bci()),
_state(block->current_state()->copy()),
@@ -339,10 +333,6 @@
}
public:
- SharkBuilder* builder() const
- {
- return block()->builder();
- }
SharkFunction* function() const
{
return block()->function();
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkFunction.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkFunction.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkFunction.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -24,105 +24,46 @@
*/
class SharkTopLevelBlock;
-
class DeferredZeroCheck;
-class SharkFunction : public StackObj {
+class SharkFunction : public SharkTargetInvariants {
public:
- SharkFunction(SharkCompiler* compiler,
- const char* name,
- ciTypeFlow* flow,
- ciBytecodeStream* iter)
- : _compiler(compiler),
- _name(name),
- _flow(flow),
- _iter(iter)
- { initialize(); }
+ SharkFunction(SharkCompiler* compiler,
+ ciEnv* env,
+ ciTypeFlow* flow,
+ const char* name)
+ : SharkTargetInvariants(compiler, env, flow), _name(name) { initialize(); }
private:
void initialize();
private:
- SharkCompiler* _compiler;
const char* _name;
- ciTypeFlow* _flow;
- ciBytecodeStream* _iter;
llvm::Function* _function;
SharkTopLevelBlock** _blocks;
- llvm::Value* _thread;
- int _max_monitors;
GrowableArray<DeferredZeroCheck*> _deferred_zero_checks;
- public:
- SharkCompiler* compiler() const
- {
- return _compiler;
- }
+ public:
const char* name() const
{
return _name;
- }
- ciTypeFlow* flow() const
- {
- return _flow;
- }
- ciBytecodeStream* iter() const
- {
- return _iter;
- }
+ }
llvm::Function* function() const
{
return _function;
- }
- SharkTopLevelBlock* block(int i) const
- {
- return _blocks[i];
- }
- llvm::Value* thread() const
- {
- return _thread;
- }
- int max_monitors() const
- {
- return _max_monitors;
- }
- GrowableArray<DeferredZeroCheck*>* deferred_zero_checks()
- {
- return &_deferred_zero_checks;
- }
-
- public:
- SharkBuilder* builder() const
- {
- return compiler()->builder();
- }
- int arg_size() const
- {
- return target()->arg_size();
}
int block_count() const
{
return flow()->block_count();
}
- DebugInformationRecorder *debug_info() const
+ SharkTopLevelBlock* block(int i) const
{
- return env()->debug_info();
+ assert(i < block_count(), "should be");
+ return _blocks[i];
}
- ciEnv* env() const
+ GrowableArray<DeferredZeroCheck*>* deferred_zero_checks()
{
- return flow()->env();
- }
- int max_locals() const
- {
- return flow()->max_locals();
- }
- int max_stack() const
- {
- return flow()->max_stack();
- }
- ciMethod* target() const
- {
- return flow()->method();
+ return &_deferred_zero_checks;
}
// Block management
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkInliner.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkInliner.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkInliner.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -30,11 +30,8 @@
class SharkInlineBlock : public SharkBlock {
public:
- SharkInlineBlock(ciMethod* target,
- SharkState* state,
- ciBytecodeStream* iter,
- Value* thread)
- : SharkBlock(state->builder(), target, iter, thread),
+ SharkInlineBlock(ciMethod* target, SharkState* state)
+ : SharkBlock(state, target),
_outer_state(state),
_entry_state(new SharkState(this))
{
@@ -80,17 +77,15 @@
class SharkInlinerHelper : public StackObj {
public:
- SharkInlinerHelper(ciMethod* target, SharkState* entry_state, Value* thread)
+ SharkInlinerHelper(ciMethod* target, SharkState* entry_state)
: _target(target),
_entry_state(entry_state),
- _iter(target),
- _thread(thread) {}
+ _iter(target) {}
private:
ciBytecodeStream _iter;
SharkState* _entry_state;
ciMethod* _target;
- Value* _thread;
public:
ciBytecodeStream* iter()
@@ -104,10 +99,6 @@
ciMethod* target() const
{
return _target;
- }
- Value* thread() const
- {
- return _thread;
}
public:
@@ -207,8 +198,7 @@
public:
void do_inline()
{
- (new SharkInlineBlock(
- target(), entry_state(), iter(), thread()))->emit_IR();
+ (new SharkInlineBlock(target(), entry_state()))->emit_IR();
}
};
@@ -770,17 +760,15 @@
return true;
}
-bool SharkInliner::attempt_inline(ciMethod* target,
- SharkState* state,
- Value* thread)
+bool SharkInliner::attempt_inline(ciMethod *target, SharkState *state)
{
if (SharkIntrinsics::is_intrinsic(target)) {
- SharkIntrinsics::inline_intrinsic(target, state, thread);
+ SharkIntrinsics::inline_intrinsic(target, state);
return true;
}
if (may_be_inlinable(target)) {
- SharkInlinerHelper inliner(target, state, thread);
+ SharkInlinerHelper inliner(target, state);
if (inliner.is_inlinable()) {
inliner.do_inline();
return true;
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkInliner.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkInliner.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkInliner.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -25,9 +25,7 @@
class SharkInliner : public AllStatic {
public:
- static bool attempt_inline(ciMethod* target,
- SharkState* state,
- llvm::Value* thread);
+ static bool attempt_inline(ciMethod* target, SharkState* state);
private:
static bool may_be_inlinable(ciMethod* target);
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkIntrinsics.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -75,67 +75,71 @@
return false;
}
-void SharkIntrinsics::inline_intrinsic(ciMethod* target,
- SharkState* state,
- Value* thread)
+void SharkIntrinsics::inline_intrinsic(ciMethod *target, SharkState *state)
{
- switch (target->intrinsic_id()) {
+ SharkIntrinsics intrinsic(state, target);
+ intrinsic.do_intrinsic();
+}
+
+void SharkIntrinsics::do_intrinsic()
+{
+ switch (target()->intrinsic_id()) {
// java.lang.Math
case vmIntrinsics::_min:
- do_Math_minmax(state, llvm::ICmpInst::ICMP_SLE);
+ do_Math_minmax(llvm::ICmpInst::ICMP_SLE);
break;
case vmIntrinsics::_max:
- do_Math_minmax(state, llvm::ICmpInst::ICMP_SGE);
+ do_Math_minmax(llvm::ICmpInst::ICMP_SGE);
break;
case vmIntrinsics::_dabs:
- do_Math_1to1(state, SharkRuntime::fabs());
+ do_Math_1to1(SharkRuntime::fabs());
break;
case vmIntrinsics::_dsin:
- do_Math_1to1(state, state->builder()->llvm_sin_fn());
+ do_Math_1to1(builder()->llvm_sin_fn());
break;
case vmIntrinsics::_dcos:
- do_Math_1to1(state, state->builder()->llvm_cos_fn());
+ do_Math_1to1(builder()->llvm_cos_fn());
break;
case vmIntrinsics::_dtan:
- do_Math_1to1(state, SharkRuntime::tan());
+ do_Math_1to1(SharkRuntime::tan());
break;
case vmIntrinsics::_datan2:
- do_Math_2to1(state, SharkRuntime::atan2());
+ do_Math_2to1(SharkRuntime::atan2());
break;
case vmIntrinsics::_dsqrt:
- do_Math_1to1(state, state->builder()->llvm_sqrt_fn());
+ do_Math_1to1(builder()->llvm_sqrt_fn());
break;
case vmIntrinsics::_dlog:
- do_Math_1to1(state, state->builder()->llvm_log_fn());
+ do_Math_1to1(builder()->llvm_log_fn());
break;
case vmIntrinsics::_dlog10:
- do_Math_1to1(state, state->builder()->llvm_log10_fn());
+ do_Math_1to1(builder()->llvm_log10_fn());
break;
case vmIntrinsics::_dpow:
- do_Math_2to1(state, state->builder()->llvm_pow_fn());
+ do_Math_2to1(builder()->llvm_pow_fn());
break;
case vmIntrinsics::_dexp:
- do_Math_1to1(state, state->builder()->llvm_exp_fn());
+ do_Math_1to1(builder()->llvm_exp_fn());
break;
// java.lang.Object
case vmIntrinsics::_getClass:
- do_Object_getClass(state);
+ do_Object_getClass();
break;
// java.lang.System
case vmIntrinsics::_currentTimeMillis:
- do_System_currentTimeMillis(state);
+ do_System_currentTimeMillis();
break;
// java.lang.Thread
case vmIntrinsics::_currentThread:
- do_Thread_currentThread(state, thread);
+ do_Thread_currentThread();
break;
// sun.misc.Unsafe
case vmIntrinsics::_compareAndSwapInt:
- do_Unsafe_compareAndSwapInt(state);
+ do_Unsafe_compareAndSwapInt();
break;
default:
@@ -143,85 +147,83 @@
}
}
-void SharkIntrinsics::do_Math_minmax(SharkState *state, ICmpInst::Predicate p)
+void SharkIntrinsics::do_Math_minmax(ICmpInst::Predicate p)
{
- SharkBuilder *builder = state->builder();
-
// Pop the arguments
- SharkValue *sb = state->pop();
- SharkValue *sa = state->pop();
+ SharkValue *sb = state()->pop();
+ SharkValue *sa = state()->pop();
Value *a = sa->jint_value();
Value *b = sb->jint_value();
// Perform the test
- BasicBlock *ip = builder->GetBlockInsertionPoint();
- BasicBlock *return_a = builder->CreateBlock(ip, "return_a");
- BasicBlock *return_b = builder->CreateBlock(ip, "return_b");
- BasicBlock *done = builder->CreateBlock(ip, "done");
+ BasicBlock *ip = builder()->GetBlockInsertionPoint();
+ BasicBlock *return_a = builder()->CreateBlock(ip, "return_a");
+ BasicBlock *return_b = builder()->CreateBlock(ip, "return_b");
+ BasicBlock *done = builder()->CreateBlock(ip, "done");
- builder->CreateCondBr(builder->CreateICmp(p, a, b), return_a, return_b);
+ builder()->CreateCondBr(builder()->CreateICmp(p, a, b), return_a, return_b);
- builder->SetInsertPoint(return_a);
- builder->CreateBr(done);
+ builder()->SetInsertPoint(return_a);
+ builder()->CreateBr(done);
- builder->SetInsertPoint(return_b);
- builder->CreateBr(done);
+ builder()->SetInsertPoint(return_b);
+ builder()->CreateBr(done);
- builder->SetInsertPoint(done);
- PHINode *phi = builder->CreatePHI(a->getType(), "result");
+ builder()->SetInsertPoint(done);
+ PHINode *phi = builder()->CreatePHI(a->getType(), "result");
phi->addIncoming(a, return_a);
phi->addIncoming(b, return_b);
// Push the result
- state->push(
+ state()->push(
SharkValue::create_jint(
phi,
sa->zero_checked() && sb->zero_checked()));
}
-void SharkIntrinsics::do_Math_1to1(SharkState *state, Constant *function)
+void SharkIntrinsics::do_Math_1to1(Constant *function)
{
- SharkValue *empty = state->pop();
+ SharkValue *empty = state()->pop();
assert(empty == NULL, "should be");
- state->push(
+ state()->push(
SharkValue::create_jdouble(
- state->builder()->CreateCall(function, state->pop()->jdouble_value())));
- state->push(NULL);
+ builder()->CreateCall(
+ function, state()->pop()->jdouble_value())));
+ state()->push(NULL);
}
-void SharkIntrinsics::do_Math_2to1(SharkState *state, Constant *function)
+void SharkIntrinsics::do_Math_2to1(Constant *function)
{
- SharkValue *empty = state->pop();
+ SharkValue *empty = state()->pop();
assert(empty == NULL, "should be");
- Value *y = state->pop()->jdouble_value();
- empty = state->pop();
+ Value *y = state()->pop()->jdouble_value();
+ empty = state()->pop();
assert(empty == NULL, "should be");
- Value *x = state->pop()->jdouble_value();
+ Value *x = state()->pop()->jdouble_value();
- state->push(
- SharkValue::create_jdouble(state->builder()->CreateCall2(function, x, y)));
- state->push(NULL);
+ state()->push(
+ SharkValue::create_jdouble(
+ builder()->CreateCall2(function, x, y)));
+ state()->push(NULL);
}
-void SharkIntrinsics::do_Object_getClass(SharkState *state)
+void SharkIntrinsics::do_Object_getClass()
{
- SharkBuilder *builder = state->builder();
-
- Value *klass = builder->CreateValueOfStructEntry(
- state->pop()->jobject_value(),
+ Value *klass = builder()->CreateValueOfStructEntry(
+ state()->pop()->jobject_value(),
in_ByteSize(oopDesc::klass_offset_in_bytes()),
SharkType::jobject_type(),
"klass");
- Value *klass_part = builder->CreateAddressOfStructEntry(
+ Value *klass_part = builder()->CreateAddressOfStructEntry(
klass,
in_ByteSize(klassOopDesc::klass_part_offset_in_bytes()),
SharkType::klass_type(),
"klass_part");
- state->push(
+ state()->push(
SharkValue::create_jobject(
- builder->CreateValueOfStructEntry(
+ builder()->CreateValueOfStructEntry(
klass_part,
in_ByteSize(Klass::java_mirror_offset_in_bytes()),
SharkType::oop_type(),
@@ -229,59 +231,57 @@
true));
}
-void SharkIntrinsics::do_System_currentTimeMillis(SharkState *state)
+void SharkIntrinsics::do_System_currentTimeMillis()
{
- state->push(
+ state()->push(
SharkValue::create_jlong(
- state->builder()->CreateCall(SharkRuntime::current_time_millis()),
+ builder()->CreateCall(SharkRuntime::current_time_millis()),
false));
- state->push(NULL);
+ state()->push(NULL);
}
-void SharkIntrinsics::do_Thread_currentThread(SharkState *state, Value *thread)
+void SharkIntrinsics::do_Thread_currentThread()
{
- state->push(
+ state()->push(
SharkValue::create_jobject(
- state->builder()->CreateValueOfStructEntry(
- thread, JavaThread::threadObj_offset(),
+ builder()->CreateValueOfStructEntry(
+ thread(), JavaThread::threadObj_offset(),
SharkType::jobject_type(),
"threadObj"),
true));
}
-void SharkIntrinsics::do_Unsafe_compareAndSwapInt(SharkState *state)
+void SharkIntrinsics::do_Unsafe_compareAndSwapInt()
{
- SharkBuilder *builder = state->builder();
-
// Pop the arguments
- Value *x = state->pop()->jint_value();
- Value *e = state->pop()->jint_value();
- SharkValue *empty = state->pop();
+ Value *x = state()->pop()->jint_value();
+ Value *e = state()->pop()->jint_value();
+ SharkValue *empty = state()->pop();
assert(empty == NULL, "should be");
- Value *offset = state->pop()->jlong_value();
- Value *object = state->pop()->jobject_value();
- Value *unsafe = state->pop()->jobject_value();
+ Value *offset = state()->pop()->jlong_value();
+ Value *object = state()->pop()->jobject_value();
+ Value *unsafe = state()->pop()->jobject_value();
// Convert the offset
- offset = builder->CreateCall(
+ offset = builder()->CreateCall(
SharkRuntime::unsafe_field_offset_to_byte_offset(),
offset);
// Locate the field
- Value *addr = builder->CreateIntToPtr(
- builder->CreateAdd(
- builder->CreatePtrToInt(object, SharkType::intptr_type()),
- builder->CreateIntCast(offset, SharkType::intptr_type(), true)),
+ Value *addr = builder()->CreateIntToPtr(
+ builder()->CreateAdd(
+ builder()->CreatePtrToInt(object, SharkType::intptr_type()),
+ builder()->CreateIntCast(offset, SharkType::intptr_type(), true)),
PointerType::getUnqual(SharkType::jint_type()),
"addr");
// Perform the operation
- Value *result = builder->CreateCmpxchgInt(x, addr, e);
+ Value *result = builder()->CreateCmpxchgInt(x, addr, e);
// Push the result
- state->push(
+ state()->push(
SharkValue::create_jint(
- builder->CreateIntCast(
- builder->CreateICmpEQ(result, e), SharkType::jint_type(), true),
+ builder()->CreateIntCast(
+ builder()->CreateICmpEQ(result, e), SharkType::jint_type(), true),
false));
}
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkIntrinsics.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -23,19 +23,33 @@
*
*/
-class SharkIntrinsics : public AllStatic {
+class SharkIntrinsics : public SharkTargetInvariants {
public:
static bool is_intrinsic(ciMethod* target);
- static void inline_intrinsic(ciMethod* target,
- SharkState* state,
- llvm::Value* thread);
+ static void inline_intrinsic(ciMethod* target, SharkState* state);
private:
- static void do_Math_minmax(SharkState* state, llvm::ICmpInst::Predicate p);
- static void do_Math_1to1(SharkState* state, llvm::Constant* function);
- static void do_Math_2to1(SharkState* state, llvm::Constant* function);
- static void do_Object_getClass(SharkState* state);
- static void do_System_currentTimeMillis(SharkState* state);
- static void do_Thread_currentThread(SharkState* state, llvm::Value* thread);
- static void do_Unsafe_compareAndSwapInt(SharkState* state);
+ SharkIntrinsics(SharkState* state, ciMethod* target)
+ : SharkTargetInvariants(state, target), _state(state) {}
+
+ private:
+ SharkState* _state;
+
+ private:
+ SharkState* state() const
+ {
+ return _state;
+ }
+
+ private:
+ void do_intrinsic();
+
+ 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_Object_getClass();
+ void do_System_currentTimeMillis();
+ void do_Thread_currentThread();
+ void do_Unsafe_compareAndSwapInt();
};
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkInvariants.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ports/hotspot/src/share/vm/shark/sharkInvariants.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -0,0 +1,38 @@
+/*
+ * Copyright 1999-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_sharkInvariants.cpp.incl"
+
+int SharkTargetInvariants::count_monitors()
+{
+ int result = 0;
+ if (is_synchronized() || target()->has_monitor_bytecodes()) {
+ for (int i = 0; i < flow()->block_count(); i++) {
+ result = MAX2(result, flow()->pre_order_at(i)->monitor_count());
+ }
+ }
+ return result;
+}
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkInvariants.hpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ports/hotspot/src/share/vm/shark/sharkInvariants.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -0,0 +1,186 @@
+/*
+ * Copyright 1999-2007 Sun Microsystems, Inc. All Rights Reserved.
+ * 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// Base classes used to track various values through the compilation.
+// SharkCompileInvariants is used to track values which remain the
+// same for the top-level method and any inlined methods it may have
+// (ie for the whole compilation). SharkTargetInvariants is used to
+// track values which differ between methods.
+
+class SharkCompileInvariants : public ResourceObj {
+ protected:
+ SharkCompileInvariants(SharkCompiler* compiler, ciEnv* env)
+ : _compiler(compiler),
+ _env(env),
+ _thread(NULL) {}
+
+ SharkCompileInvariants(const SharkCompileInvariants* parent)
+ : _compiler(parent->_compiler),
+ _env(parent->_env),
+ _thread(parent->_thread) {}
+
+ private:
+ SharkCompiler* _compiler;
+ ciEnv* _env;
+ 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.
+ protected:
+ SharkCompiler* compiler() const
+ {
+ return _compiler;
+ }
+
+ // Top-level broker for HotSpot's Compiler Interface.
+ //
+ // Its main purpose is to allow the various CI classes to access
+ // oops in the VM without having to worry about safepointing. In
+ // addition to this it acts as a holder for various recorders and
+ // memory allocators.
+ //
+ // Accessing this directly is kind of ugly, so it's private. Add
+ // new accessors below if you need something from it.
+ private:
+ ciEnv* env() const
+ {
+ return _env;
+ }
+
+ // 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
+ // invariance.
+ protected:
+ llvm::Value* thread() const
+ {
+ assert(_thread != NULL, "thread not available");
+ return _thread;
+ }
+ void set_thread(llvm::Value* thread)
+ {
+ assert(_thread == NULL, "thread already set");
+ _thread = thread;
+ }
+
+ // Objects that handle various aspects of the compilation.
+ protected:
+ SharkBuilder* builder() const
+ {
+ return compiler()->builder();
+ }
+ SharkMemoryManager* memory_manager() const
+ {
+ return compiler()->memory_manager();
+ }
+ DebugInformationRecorder* debug_info() const
+ {
+ return env()->debug_info();
+ }
+ Dependencies* dependencies() const
+ {
+ return env()->dependencies();
+ }
+
+ // That well-known class...
+ protected:
+ ciInstanceKlass* java_lang_Object_klass() const
+ {
+ return env()->Object_klass();
+ }
+};
+
+class SharkTargetInvariants : public SharkCompileInvariants {
+ protected:
+ SharkTargetInvariants(SharkCompiler* compiler, ciEnv* env, ciTypeFlow* flow)
+ : SharkCompileInvariants(compiler, env),
+ _target(flow->method()),
+ _flow(flow),
+ _max_monitors(count_monitors()) {}
+
+ SharkTargetInvariants(const SharkCompileInvariants* parent, ciMethod* target)
+ : SharkCompileInvariants(parent),
+ _target(target),
+ _flow(NULL),
+ _max_monitors(count_monitors()) {}
+
+ SharkTargetInvariants(const SharkTargetInvariants* parent)
+ : SharkCompileInvariants(parent),
+ _target(parent->_target),
+ _flow(parent->_flow),
+ _max_monitors(parent->_max_monitors) {}
+
+ private:
+ int count_monitors();
+
+ private:
+ ciMethod* _target;
+ ciTypeFlow* _flow;
+ int _max_monitors;
+
+ // The method being compiled.
+ protected:
+ ciMethod* target() const
+ {
+ return _target;
+ }
+
+ // Typeflow analysis of the method being compiled.
+ protected:
+ ciTypeFlow* flow() const
+ {
+ assert(_flow != NULL, "typeflow not available");
+ return _flow;
+ }
+
+ // Properties of the method.
+ protected:
+ int max_locals() const
+ {
+ return target()->max_locals();
+ }
+ int max_stack() const
+ {
+ return target()->max_stack();
+ }
+ int max_monitors() const
+ {
+ return _max_monitors;
+ }
+ int arg_size() const
+ {
+ return target()->arg_size();
+ }
+ bool is_static() const
+ {
+ return target()->is_static();
+ }
+ bool is_synchronized() const
+ {
+ return target()->is_synchronized();
+ }
+};
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkState.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkState.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkState.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -27,26 +27,6 @@
#include "incls/_sharkState.cpp.incl"
using namespace llvm;
-
-SharkState::SharkState(SharkBlock* block, SharkFunction* function)
- : _block(block),
- _function(function),
- _method(NULL),
- _oop_tmp(NULL),
- _has_safepointed(false)
-{
- initialize(NULL);
-}
-
-SharkState::SharkState(SharkBlock* block, const SharkState* state)
- : _block(block),
- _function(state->function()),
- _method(state->method()),
- _oop_tmp(state->oop_tmp()),
- _has_safepointed(state->has_safepointed())
-{
- initialize(state);
-}
void SharkState::initialize(const SharkState *state)
{
@@ -78,10 +58,7 @@
bool SharkState::equal_to(SharkState *other)
{
- if (block() != other->block())
- return false;
-
- if (function() != other->function())
+ if (target() != other->target())
return false;
if (method() != other->method())
@@ -216,57 +193,8 @@
}
}
-void SharkState::decache_for_Java_call(ciMethod* callee)
-{
- assert(function() && method(), "you cannot decache here");
- SharkJavaCallDecacher(function(), block()->bci(), callee).scan(this);
- pop(callee->arg_size());
-}
-
-void SharkState::cache_after_Java_call(ciMethod* callee)
-{
- assert(function() && method(), "you cannot cache here");
- if (callee->return_type()->size()) {
- ciType *type;
- switch (callee->return_type()->basic_type()) {
- case T_BOOLEAN:
- case T_BYTE:
- case T_CHAR:
- case T_SHORT:
- type = ciType::make(T_INT);
- break;
-
- default:
- type = callee->return_type();
- }
-
- push(SharkValue::create_generic(type, NULL, false));
- if (type->is_two_word())
- push(NULL);
- }
- SharkJavaCallCacher(function(), callee).scan(this);
-}
-
-void SharkState::decache_for_VM_call()
-{
- assert(function() && method(), "you cannot decache here");
- SharkVMCallDecacher(function(), block()->bci()).scan(this);
-}
-
-void SharkState::cache_after_VM_call()
-{
- assert(function() && method(), "you cannot cache here");
- SharkVMCallCacher(function()).scan(this);
-}
-
-void SharkState::decache_for_trap()
-{
- assert(function() && method(), "you cannot decache here");
- SharkTrapDecacher(function(), block()->bci()).scan(this);
-}
-
SharkEntryState::SharkEntryState(SharkTopLevelBlock* block, Value* method)
- : SharkState(block, block->function())
+ : SharkState(block)
{
assert(!block->stack_depth_at_entry(), "entry block shouldn't have stack");
@@ -282,11 +210,10 @@
case T_DOUBLE:
case T_OBJECT:
case T_ARRAY:
- if (i >= function()->arg_size()) {
+ if (i >= arg_size()) {
ShouldNotReachHere();
}
- value = SharkValue::create_generic(
- type, NULL, i == 0 && !function()->target()->is_static());
+ value = SharkValue::create_generic(type, NULL, i == 0 && !is_static());
break;
case ciTypeFlow::StateVector::T_BOTTOM:
@@ -301,11 +228,11 @@
}
set_local(i, value);
}
- SharkFunctionEntryCacher(function(), method).scan(this);
+ SharkFunctionEntryCacher(block->function(), method).scan(this);
}
SharkPHIState::SharkPHIState(SharkTopLevelBlock* block)
- : SharkState(block, block->function())
+ : SharkState(block), _block(block)
{
BasicBlock *saved_insert_point = builder()->GetInsertBlock();
builder()->SetInsertPoint(block->entry_block());
@@ -407,7 +334,7 @@
}
// Expression stack
- int stack_depth = ((SharkTopLevelBlock *) block())->stack_depth_at_entry();
+ int stack_depth = block()->stack_depth_at_entry();
assert(stack_depth == incoming_state->stack_depth(), "should be");
for (int i = 0; i < stack_depth; i++) {
assert((stack(i) == NULL) == (incoming_state->stack(i) == NULL), "oops");
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkState.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkState.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkState.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -23,44 +23,31 @@
*
*/
-class SharkBlock;
-class SharkFunction;
-class SharkTopLevelBlock;
+class SharkState : public SharkTargetInvariants {
+ public:
+ SharkState(const SharkTargetInvariants* parent)
+ : SharkTargetInvariants(parent),
+ _method(NULL),
+ _oop_tmp(NULL),
+ _has_safepointed(false) { initialize(NULL); }
-class SharkState : public ResourceObj {
- public:
- SharkState(SharkBlock* block, SharkFunction* function = NULL);
- SharkState(SharkBlock* block, const SharkState* state);
+ SharkState(const SharkState* state)
+ : SharkTargetInvariants(state),
+ _method(state->_method),
+ _oop_tmp(state->_oop_tmp),
+ _has_safepointed(state->_has_safepointed) { initialize(state); }
private:
void initialize(const SharkState* state);
private:
- SharkBlock* _block;
- SharkFunction* _function;
- llvm::Value* _method;
- SharkValue** _locals;
- SharkValue** _stack;
- SharkValue** _sp;
- int _num_monitors;
- llvm::Value* _oop_tmp;
- bool _has_safepointed;
-
- public:
- SharkBlock *block() const
- {
- return _block;
- }
- SharkFunction *function() const
- {
- return _function;
- }
-
- public:
- inline SharkBuilder* builder() const;
- inline int max_locals() const;
- inline int max_stack() const;
- inline int max_monitors() const;
+ llvm::Value* _method;
+ SharkValue** _locals;
+ SharkValue** _stack;
+ SharkValue** _sp;
+ int _num_monitors;
+ llvm::Value* _oop_tmp;
+ bool _has_safepointed;
// Method
public:
@@ -125,11 +112,6 @@
assert(stack_depth() > 0, "stack underrun");
return *(--_sp);
}
- void pop(int slots)
- {
- assert(stack_depth() >= slots, "stack underrun");
- _sp -= slots;
- }
// Monitors
public:
@@ -176,7 +158,7 @@
public:
SharkState* copy() const
{
- return new SharkState(block(), this);
+ return new SharkState(this);
}
void merge(SharkState* other,
llvm::BasicBlock* other_block,
@@ -185,15 +167,9 @@
// Value replacement
public:
void replace_all(SharkValue* old_value, SharkValue* new_value);
+};
- // Cache and decache
- public:
- void decache_for_Java_call(ciMethod* callee);
- void cache_after_Java_call(ciMethod* callee);
- void decache_for_VM_call();
- void cache_after_VM_call();
- void decache_for_trap();
-};
+class SharkTopLevelBlock;
// SharkEntryState objects are used to manage the state
// that the method will be entered with.
@@ -209,6 +185,15 @@
public:
SharkPHIState(SharkTopLevelBlock* block);
+ private:
+ SharkTopLevelBlock* _block;
+
+ private:
+ SharkTopLevelBlock* block() const
+ {
+ return _block;
+ }
+
public:
void add_incoming(SharkState* incoming_state);
};
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkState.inline.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkState.inline.hpp Thu Jun 18 10:58:02 2009 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,44 +0,0 @@
-/*
- * Copyright 1999-2007 Sun Microsystems, Inc. All Rights Reserved.
- * 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
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
- * CA 95054 USA or visit www.sun.com if you need additional information or
- * have any questions.
- *
- */
-
-inline SharkBuilder* SharkState::builder() const
-{
- return block()->builder();
-}
-
-inline int SharkState::max_locals() const
-{
- return block()->max_locals();
-}
-
-inline int SharkState::max_stack() const
-{
- return block()->max_stack();
-}
-
-inline int SharkState::max_monitors() const
-{
- return function()->max_monitors();
-}
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkStateScanner.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkStateScanner.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkStateScanner.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -34,13 +34,13 @@
// Expression stack
stack_integrity_checks(state);
- start_stack(state->stack_depth(), state->max_stack());
+ start_stack(state->stack_depth());
for (int i = state->stack_depth() - 1; i >= 0; i--) {
process_stack_slot(
i,
state->stack_addr(i),
function()->stack_slots_offset() +
- i + state->max_stack() - state->stack_depth());
+ i + max_stack() - state->stack_depth());
}
end_stack();
@@ -64,12 +64,12 @@
// Local variables
locals_integrity_checks(state);
- start_locals(state->max_locals());
- for (int i = 0; i < state->max_locals(); i++) {
+ start_locals();
+ for (int i = 0; i < max_locals(); i++) {
process_local_slot(
i,
state->local_addr(i),
- function()->locals_slots_offset() + state->max_locals() - 1 - i);
+ function()->locals_slots_offset() + max_locals() - 1 - i);
}
end_locals();
@@ -92,7 +92,7 @@
void SharkStateScanner::locals_integrity_checks(SharkState* state)
{
- for (int i = 0; i < state->max_locals(); i++) {
+ for (int i = 0; i < max_locals(); i++) {
if (state->local(i)) {
if (state->local(i)->is_two_word())
assert(state->local(i + 1) == NULL, "should be");
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkStateScanner.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkStateScanner.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkStateScanner.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -25,10 +25,10 @@
class SharkState;
-class SharkStateScanner : public StackObj {
+class SharkStateScanner : public SharkTargetInvariants {
protected:
SharkStateScanner(SharkFunction* function)
- : _function(function) {}
+ : SharkTargetInvariants(function), _function(function) {}
private:
SharkFunction* _function;
@@ -49,7 +49,7 @@
protected:
virtual void start_frame() {}
- virtual void start_stack(int num_slots, int max_slots) {}
+ virtual void start_stack(int stack_depth) {}
virtual void process_stack_slot(int index, SharkValue** value, int offset) {}
virtual void end_stack() {}
@@ -63,7 +63,7 @@
virtual void process_pc_slot(int offset) {}
virtual void end_frame_header() {}
- virtual void start_locals(int num_locals) {}
+ virtual void start_locals() {}
virtual void process_local_slot(int index, SharkValue** value, int offset) {}
virtual void end_locals() {}
@@ -71,6 +71,6 @@
// Integrity checks
private:
- static void stack_integrity_checks(SharkState* state) PRODUCT_RETURN;
- static void locals_integrity_checks(SharkState* state) PRODUCT_RETURN;
+ void stack_integrity_checks(SharkState* state) PRODUCT_RETURN;
+ void locals_integrity_checks(SharkState* state) PRODUCT_RETURN;
};
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp
--- a/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.cpp Thu Jun 18 12:00:59 2009 -0400
@@ -189,6 +189,49 @@
"bci_%d%s",
start(), is_backedge_copy() ? "_backedge_copy" : "");
_entry_block = function()->CreateBlock(name);
+}
+
+void SharkTopLevelBlock::decache_for_Java_call(ciMethod *callee)
+{
+ SharkJavaCallDecacher(function(), bci(), callee).scan(current_state());
+ for (int i = 0; i < callee->arg_size(); i++)
+ xpop();
+}
+
+void SharkTopLevelBlock::cache_after_Java_call(ciMethod *callee)
+{
+ if (callee->return_type()->size()) {
+ ciType *type;
+ switch (callee->return_type()->basic_type()) {
+ case T_BOOLEAN:
+ case T_BYTE:
+ case T_CHAR:
+ case T_SHORT:
+ type = ciType::make(T_INT);
+ break;
+
+ default:
+ type = callee->return_type();
+ }
+
+ push(SharkValue::create_generic(type, NULL, false));
+ }
+ SharkJavaCallCacher(function(), callee).scan(current_state());
+}
+
+void SharkTopLevelBlock::decache_for_VM_call()
+{
+ SharkVMCallDecacher(function(), bci()).scan(current_state());
+}
+
+void SharkTopLevelBlock::cache_after_VM_call()
+{
+ SharkVMCallCacher(function()).scan(current_state());
+}
+
+void SharkTopLevelBlock::decache_for_trap()
+{
+ SharkTrapDecacher(function(), bci()).scan(current_state());
}
void SharkTopLevelBlock::emit_IR()
@@ -508,7 +551,7 @@
void SharkTopLevelBlock::do_trap(int trap_request)
{
- current_state()->decache_for_trap();
+ decache_for_trap();
builder()->CreateCall2(
SharkRuntime::uncommon_trap(),
thread(),
@@ -828,7 +871,7 @@
// Array methods are all inherited from Object and are monomorphic
if (receiver_type->is_array_klass() &&
- dest_method->holder() == function()->env()->Object_klass())
+ dest_method->holder() == java_lang_Object_klass())
return dest_method;
// All other interesting cases are instance classes
@@ -876,7 +919,7 @@
// us dependent on that target method not getting overridden
// by dynamic class loading.
if (monomorphic_target != NULL) {
- function()->env()->dependencies()->assert_unique_concrete_method(
+ dependencies()->assert_unique_concrete_method(
actual_receiver, monomorphic_target);
return monomorphic_target;
}
@@ -1077,7 +1120,7 @@
// Try to inline the call
if (!call_is_virtual) {
- if (SharkInliner::attempt_inline(call_method, current_state(), thread()))
+ if (SharkInliner::attempt_inline(call_method, current_state()))
return;
}
@@ -1116,9 +1159,9 @@
"entry_point");
// Make the call
- current_state()->decache_for_Java_call(call_method);
+ decache_for_Java_call(call_method);
builder()->CreateCall3(entry_point, callee, base_pc, thread());
- current_state()->cache_after_Java_call(call_method);
+ cache_after_Java_call(call_method);
// Check for pending exceptions
check_pending_exception(EX_CHECK_FULL);
@@ -1133,7 +1176,7 @@
// If the class we're checking against is java.lang.Object
// then this is a no brainer. Apparently this can happen
// in reflective code...
- if (check_klass == function()->env()->Object_klass())
+ if (check_klass == java_lang_Object_klass())
return true;
// Perform a subtype check. NB in opto's code for this
@@ -1690,13 +1733,13 @@
// NB we use the entire stack, but JavaThread::is_lock_owned()
// uses a more limited range. I don't think it hurts though...
Value *stack_limit = builder()->CreateValueOfStructEntry(
- function()->thread(), Thread::stack_base_offset(),
+ thread(), Thread::stack_base_offset(),
SharkType::intptr_type(),
"stack_limit");
assert(sizeof(size_t) == sizeof(intptr_t), "should be");
Value *stack_size = builder()->CreateValueOfStructEntry(
- function()->thread(), Thread::stack_size_offset(),
+ thread(), Thread::stack_size_offset(),
SharkType::intptr_type(),
"stack_size");
diff -r e86b8e1d9de6 -r 4e8a6af384a1 ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp
--- a/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp Thu Jun 18 10:58:02 2009 +0200
+++ b/ports/hotspot/src/share/vm/shark/sharkTopLevelBlock.hpp Thu Jun 18 12:00:59 2009 -0400
@@ -26,10 +26,7 @@
class SharkTopLevelBlock : public SharkBlock {
public:
SharkTopLevelBlock(SharkFunction* function, ciTypeFlow::Block* ciblock)
- : SharkBlock(function->builder(),
- function->target(),
- function->iter(),
- function->thread()),
+ : SharkBlock(function),
_function(function),
_ciblock(ciblock),
_entered(false),
@@ -205,6 +202,14 @@
return value;
}
+ // Cache and decache
+ private:
+ void decache_for_Java_call(ciMethod* callee);
+ void cache_after_Java_call(ciMethod* callee);
+ void decache_for_VM_call();
+ void cache_after_VM_call();
+ void decache_for_trap();
+
// Monitors
private:
int num_monitors()
@@ -256,11 +261,11 @@
llvm::Value** args_end,
int exception_action)
{
- current_state()->decache_for_VM_call();
+ decache_for_VM_call();
function()->set_last_Java_frame();
llvm::CallInst *res = builder()->CreateCall(callee, args_start, args_end);
function()->reset_last_Java_frame();
- current_state()->cache_after_VM_call();
+ cache_after_VM_call();
if (exception_action & EAM_CHECK) {
check_pending_exception(exception_action);
current_state()->set_has_safepointed(true);
More information about the distro-pkg-dev
mailing list