--- a/ChangeLog	Mon Sep 29 12:04:41 2008 -0400
+++ b/ChangeLog	Tue Sep 30 08:42:10 2008 -0400
@@ -1,3 +1,52 @@
+2008-09-30  Gary Benson  <gbenson@redhat.com>
+
+	* patches/icedtea-shark.patch: Updated to latest Shark.
+	* ports/hotspot/src/cpu/zero/vm/bytecodeInterpreter_zero.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/cppInterpreter_zero.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/disassembler_zero.cpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/frame_zero.cpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/frame_zero.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/frame_zero.inline.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/interpreterFrame_zero.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/interpreter_zero.cpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/nativeInst_zero.cpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/nativeInst_zero.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/sharedRuntime_zero.cpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/sharkFrame_zero.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/stackPrinter_zero.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/stack_zero.hpp: Likewise.
+	* ports/hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp: Likewise.
+	* ports/hotspot/src/share/vm/includeDB_shark: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkBlock.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkBlock.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkBuilder.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkBuilder.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkCompiler.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkCompiler.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkConstantPool.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkConstantPool.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkEntry.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkFunction.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkFunction.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkMonitor.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkMonitor.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkRuntime.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkRuntime.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkState.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkState.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkState.inline.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkType.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkValue.hpp: Likewise.
+	* ports/hotspot/src/cpu/zero/vm/deoptimizerFrame_zero.hpp: New file.
+	* ports/hotspot/src/share/vm/shark/sharkBytecodeTracer.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkBytecodeTracer.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkCacheDecache.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkStateScanner.cpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkStateScanner.hpp: Likewise.
+	* ports/hotspot/src/share/vm/shark/sharkValue.inline.hpp: Likewise.
+
 2008-09-26  Mark Wielaard  <mark@klomp.org>
 
 	* patches/icedtea-6712835-ifnode.patch: New patch.

--- a/patches/icedtea-shark.patch	Mon Sep 29 12:04:41 2008 -0400
+++ b/patches/icedtea-shark.patch	Tue Sep 30 08:42:10 2008 -0400
@@ -303,3 +303,118 @@
  }
  
  
+diff -r 70711eb56d8e openjdk/hotspot/src/share/vm/ci/ciTypeFlow.hpp
+--- openjdk/hotspot/src/share/vm/ci/ciTypeFlow.hpp	Mon Sep 29 08:47:58 2008 +0100
++++ openjdk/hotspot/src/share/vm/ci/ciTypeFlow.hpp	Mon Sep 29 08:51:58 2008 +0100
+@@ -94,9 +94,17 @@ public:
+   private:
+     GrowableArray<JsrRecord*>* _set;
+ 
++#ifdef SHARK
++    // XXX This can be removed if it turns out we have to deal
++    // with T_ADDRESS values the same as everything else.
++  public:
++#endif // SHARK
+     JsrRecord* record_at(int i) {
+       return _set->at(i);
+     }
++#ifdef SHARK
++  private:
++#endif // SHARK
+ 
+     // Insert the given JsrRecord into the JsrSet, maintaining the order
+     // of the set and replacing any element with the same entry address.
+@@ -515,6 +523,13 @@ public:
+     ciType* local_type_at(int i) const { return _state->local_type_at(i); }
+     ciType* stack_type_at(int i) const { return _state->stack_type_at(i); }
+ 
++    // access to the JSRs
++#ifdef SHARK
++    // XXX This can be removed if it turns out we have to deal
++    // with T_ADDRESS values the same as everything else.
++    JsrSet* jsrset() const { return _jsrs; }
++#endif // SHARK
++    
+     // Get the successors for this Block.
+     GrowableArray<Block*>* successors(ciBytecodeStream* str,
+ 				      StateVector* state,
+diff -r 70711eb56d8e openjdk/hotspot/src/share/vm/runtime/deoptimization.cpp
+--- openjdk/hotspot/src/share/vm/runtime/deoptimization.cpp	Mon Sep 29 08:47:58 2008 +0100
++++ openjdk/hotspot/src/share/vm/runtime/deoptimization.cpp	Mon Sep 29 08:54:36 2008 +0100
+@@ -217,6 +217,7 @@ Deoptimization::UnrollBlock* Deoptimizat
+     
+   }
+ 
++#ifndef SHARK
+   // Compute the caller frame based on the sender sp of stub_frame and stored frame sizes info.
+   CodeBlob* cb = stub_frame.cb();
+   // Verify we have the right vframeArray
+@@ -227,6 +228,10 @@ Deoptimization::UnrollBlock* Deoptimizat
+   assert(cb->is_deoptimization_stub() || cb->is_uncommon_trap_stub(), "just checking");
+   Events::log("fetch unroll sp " INTPTR_FORMAT, unpack_sp);
+ #endif
++#else
++  intptr_t* unpack_sp = stub_frame.sender(&dummy_map).unextended_sp();
++#endif // !SHARK
++  
+   // This is a guarantee instead of an assert because if vframe doesn't match
+   // we will unpack the wrong deoptimized frame and wind up in strange places
+   // where it will be very difficult to figure out what went wrong. Better
+@@ -337,7 +342,9 @@ Deoptimization::UnrollBlock* Deoptimizat
+ 
+   frame_pcs[0] = deopt_sender.raw_pc();
+ 
++#ifndef SHARK
+   assert(CodeCache::find_blob_unsafe(frame_pcs[0]) != NULL, "bad pc");
++#endif // SHARK
+ 
+   UnrollBlock* info = new UnrollBlock(array->frame_size() * BytesPerWord, 
+ 				      caller_adjustment * BytesPerWord,
+@@ -832,7 +839,20 @@ vframeArray* Deoptimization::create_vfra
+   // stuff a C2I adapter we can properly fill in the callee-save
+   // register locations.
+   frame caller = fr.sender(reg_map);
++#ifdef ZERO
++  int frame_size;
++  {
++    // In zero, frame::sp() is the *end* of the frame, so
++    // caller.sp() - fr.sp() is the size of the *caller*.
++    RegisterMap dummy_map(thread, false);
++    frame frame_1 = thread->last_frame();
++    frame frame_2 = frame_1.sender(&dummy_map);
++    assert(frame_2.sp() == fr.sp(), "should be");
++    frame_size = frame_2.sp() - frame_1.sp();
++  }
++#else
+   int frame_size = caller.sp() - fr.sp();
++#endif // ZERO
+ 
+   frame sender = caller;
+  
+diff -r 70711eb56d8e openjdk/hotspot/src/share/vm/runtime/vframeArray.cpp
+--- openjdk/hotspot/src/share/vm/runtime/vframeArray.cpp	Mon Sep 29 08:47:58 2008 +0100
++++ openjdk/hotspot/src/share/vm/runtime/vframeArray.cpp	Mon Sep 29 08:56:26 2008 +0100
+@@ -64,6 +64,11 @@ void vframeArrayElement::fill_in(compile
+       assert(monitor->owner() == NULL || (!monitor->owner()->is_unlocked() && !monitor->owner()->has_bias_pattern()), "object must be null or locked, and unbiased");
+       BasicObjectLock* dest = _monitors->at(index);
+       dest->set_obj(monitor->owner());
++#ifdef SHARK
++      // XXX This can be removed when Shark knows
++      // which monitors are in use.
++      if (monitor->owner())
++#endif // SHARK
+       monitor->lock()->move_to(monitor->owner(), dest->lock());
+     }
+   }
+@@ -262,6 +267,11 @@ void vframeArrayElement::unpack_on_stack
+     top = iframe()->previous_monitor_in_interpreter_frame(top);
+     BasicObjectLock* src = _monitors->at(index);
+     top->set_obj(src->obj());
++#ifdef SHARK
++    // XXX This can be removed when Shark knows
++    // which monitors are in use.
++    if (src->obj())
++#endif // SHARK    
+     src->lock()->move_to(src->obj(), top->lock());
+   }
+   if (ProfileInterpreter) {

--- a/ports/hotspot/src/cpu/zero/vm/bytecodeInterpreter_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/bytecodeInterpreter_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -43,6 +43,10 @@
   {
     _method = new_method;
   }
+  inline interpreterState self_link()
+  {
+    return _self_link;
+  }
   inline void set_self_link(interpreterState new_self_link)
   {
     _self_link = new_self_link;

--- a/ports/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/cppInterpreter_zero.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -56,7 +56,24 @@
   // Allocate and initialize our frame.
   InterpreterFrame *frame = InterpreterFrame::build(stack, method, thread);
   thread->push_zero_frame(frame);
+
+  // Execute those bytecodes!
+  main_loop(0, THREAD);
+}
+
+void CppInterpreter::main_loop(int recurse, TRAPS)
+{
+  JavaThread *thread = (JavaThread *) THREAD;
+  ZeroStack *stack = thread->zero_stack();
+
+  // If we are entering from a deopt we may need to call
+  // ourself a few times in order to get to our frame.
+  if (recurse)
+    main_loop(recurse - 1, THREAD);
+
+  InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
   interpreterState istate = frame->interpreter_state();
+  methodOop method = istate->method();
 
   intptr_t *result = NULL;
   int result_slots = 0;
@@ -79,13 +96,13 @@
 
     // Examine the message from the interpreter to decide what to do
     if (istate->msg() == BytecodeInterpreter::call_method) {
-      method = istate->callee();
+      methodOop callee = istate->callee();
 
       // Trim back the stack to put the parameters at the top
       stack->set_sp(istate->stack() + 1);
     
       // Make the call
-      Interpreter::invoke_method(method, istate->callee_entry_point(), THREAD);
+      Interpreter::invoke_method(callee, istate->callee_entry_point(), THREAD);
       fixup_after_potential_safepoint();
 
       // Convert the result
@@ -95,7 +112,6 @@
       stack->set_sp(istate->stack_limit() + 1);    
 
       // Resume the interpreter
-      method = istate->method();
       istate->set_msg(BytecodeInterpreter::method_resume);
     }
     else if (istate->msg() == BytecodeInterpreter::more_monitors) {
@@ -689,26 +705,123 @@
    generate_all();
 }
 
-// Helper for (runtime) stack overflow checks
+// Deoptimization helpers
 
-int AbstractInterpreter::size_top_interpreter_activation(methodOop method)
+InterpreterFrame *InterpreterFrame::build(ZeroStack* stack, int size)
 {
-  return 0;
+  int size_in_words = size >> LogBytesPerWord;
+  assert(size_in_words * wordSize == size, "unaligned");
+  assert(size_in_words >= header_words, "too small");
+
+  if (size_in_words > stack->available_words()) {
+    Unimplemented();
+  }
+
+  stack->push(0); // next_frame, filled in later
+  intptr_t *fp = stack->sp();
+  assert(fp - stack->sp() == next_frame_off, "should be");
+
+  stack->push(INTERPRETER_FRAME);
+  assert(fp - stack->sp() == frame_type_off, "should be");
+
+  interpreterState istate =
+    (interpreterState) stack->alloc(sizeof(BytecodeInterpreter));
+  assert(fp - stack->sp() == istate_off, "should be");
+  istate->set_self_link(NULL); // mark invalid
+
+  stack->alloc((size_in_words - header_words) * wordSize);
+
+  return (InterpreterFrame *) fp;
 }
 
-// Deoptimization helpers for C++ interpreter
-
 int AbstractInterpreter::layout_activation(methodOop method,
-                                           int tempcount,
-                                           int popframe_extra_args,
-                                           int moncount,
-                                           int callee_param_count,
-                                           int callee_locals,
-                                           frame* caller,
-                                           frame* interpreter_frame,
-                                           bool is_top_frame)
+                                           int       tempcount,
+                                           int       popframe_extra_args,
+                                           int       moncount,
+                                           int       callee_param_count,
+                                           int       callee_locals,
+                                           frame*    caller,
+                                           frame*    interpreter_frame,
+                                           bool      is_top_frame)
 {
-  Unimplemented();
+  assert(popframe_extra_args == 0, "what to do?");
+  assert(!is_top_frame || (!callee_locals && !callee_param_count),
+         "top frame should have no caller")
+
+  // This code must exactly match what InterpreterFrame::build
+  // does (the full InterpreterFrame::build, that is, not the
+  // one that creates empty frames for the deoptimizer).
+  //
+  // If interpreter_frame is not NULL then it will be filled in.
+  // It's size is determined by a previous call to this method,
+  // so it should be correct.
+  //
+  // Note that tempcount is the current size of the expression
+  // stack.  For top most frames we will allocate a full sized
+  // expression stack and not the trimmed version that non-top
+  // frames have.
+
+  int header_words        = InterpreterFrame::header_words;
+  int monitor_words       = moncount * frame::interpreter_frame_monitor_size();
+  int stack_words         = is_top_frame ? method->max_stack() : tempcount;
+  int callee_extra_locals = callee_locals - callee_param_count;
+
+  if (interpreter_frame) {
+    intptr_t *locals        = interpreter_frame->sp() + method->max_locals();
+    interpreterState istate = interpreter_frame->get_interpreterState();
+    intptr_t *monitor_base  = (intptr_t*) istate;
+    intptr_t *stack_base    = monitor_base - monitor_words;
+    intptr_t *stack         = stack_base - tempcount - 1;
+
+    BytecodeInterpreter::layout_interpreterState(istate, 
+                                                 caller,
+                                                 NULL,
+                                                 method, 
+                                                 locals, 
+                                                 stack, 
+                                                 stack_base, 
+                                                 monitor_base, 
+                                                 NULL,
+                                                 is_top_frame);
+  }
+  return header_words + monitor_words + stack_words + callee_extra_locals;
+}
+
+void BytecodeInterpreter::layout_interpreterState(interpreterState istate,
+                                                  frame*    caller,
+                                                  frame*    current,
+                                                  methodOop method,
+                                                  intptr_t* locals,
+                                                  intptr_t* stack,
+                                                  intptr_t* stack_base,
+                                                  intptr_t* monitor_base,
+                                                  intptr_t* frame_bottom,
+                                                  bool      is_top_frame)
+{
+  istate->set_locals(locals);
+  istate->set_method(method);
+  istate->set_self_link(istate);
+  istate->set_prev_link(NULL);
+  // thread will be set by a hacky repurposing of frame::patch_pc()
+  // bcp will be set by vframeArrayElement::unpack_on_stack()
+  istate->set_constants(method->constants()->cache());
+  istate->set_msg(BytecodeInterpreter::method_resume);
+  istate->set_bcp_advance(0);
+  istate->set_oop_temp(NULL);
+  istate->set_mdx(NULL);
+  if (caller->is_interpreted_frame()) {
+    interpreterState prev = caller->get_interpreterState();
+    prev->set_callee(method);
+    if (*prev->bcp() == Bytecodes::_invokeinterface)
+      prev->set_bcp_advance(5);
+    else
+      prev->set_bcp_advance(3);
+  }
+  istate->set_callee(NULL);
+  istate->set_monitor_base((BasicObjectLock *) monitor_base);
+  istate->set_stack_base(stack_base);
+  istate->set_stack(stack);
+  istate->set_stack_limit(stack_base - method->max_stack() - 1);
 }
 
 address CppInterpreter::return_entry(TosState state, int length)
@@ -718,12 +831,29 @@
 
 address CppInterpreter::deopt_entry(TosState state, int length)
 {
+#ifdef SHARK
+  return NULL;
+#else
   Unimplemented();
+#endif // SHARK
 }
 
+// Helper for (runtime) stack overflow checks
+
+int AbstractInterpreter::size_top_interpreter_activation(methodOop method)
+{
+  return 0;
+}
+
+// Helper for figuring out if frames are interpreter frames
+
 bool CppInterpreter::contains(address pc)
 {
+#ifdef PRODUCT
   ShouldNotCallThis();
+#else
+  return false; // make frame::print_value_on work
+#endif // !PRODUCT  
 }
 
 // Result handlers and convertors

--- a/ports/hotspot/src/cpu/zero/vm/cppInterpreter_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/cppInterpreter_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -28,9 +28,13 @@
   // Size of interpreter code
   const static int InterpreterCodeSize = 6 * K;
 
- private:
+ public:
   // Method entries
   static void normal_entry(methodOop method, intptr_t UNUSED, TRAPS);
   static void native_entry(methodOop method, intptr_t UNUSED, TRAPS);
   static void accessor_entry(methodOop method, intptr_t UNUSED, TRAPS);
   static void empty_entry(methodOop method, intptr_t UNUSED, TRAPS);
+
+ public:
+  // Main loop of normal_entry
+  static void main_loop(int recurse, TRAPS);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ports/hotspot/src/cpu/zero/vm/deoptimizerFrame_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 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.
+ *
+ */
+
+// |  ...               |
+// +--------------------+  ------------------
+// | frame_type         |       low addresses
+// | next_frame         |      high addresses
+// +--------------------+  ------------------
+// |  ...               |
+
+class DeoptimizerFrame : public ZeroFrame {
+  friend class ZeroStackPrinter;
+
+ private:
+  DeoptimizerFrame() : ZeroFrame()
+  {
+    ShouldNotCallThis();
+  }
+
+ protected:
+  enum Layout {
+    header_words = jf_header_words
+  };
+
+ public:
+  static DeoptimizerFrame *build(ZeroStack* stack);
+};

--- a/ports/hotspot/src/cpu/zero/vm/disassembler_zero.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/disassembler_zero.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -36,12 +36,7 @@
 {
 #ifdef SHARK
   assert(st == NULL, "it's all going to stderr anyway");
-
-  intptr_t *method_entry_addr = (intptr_t *) nm->instructions_begin();
-  intptr_t *function_addr = method_entry_addr + 1;
-  llvm::Function *function = *(llvm::Function **) function_addr;
-
-  function->dump();
+  ((SharkEntry *) nm->instructions_begin())->llvm_function()->dump();
 #else
   Unimplemented();
 #endif // SHARK

--- a/ports/hotspot/src/cpu/zero/vm/frame_zero.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/frame_zero.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -38,6 +38,11 @@
   return zeroframe()->is_interpreter_frame();
 }
 
+bool frame::is_deoptimizer_frame() const
+{
+  return zeroframe()->is_deoptimizer_frame();
+}
+
 frame frame::sender_for_entry_frame(RegisterMap *map) const
 {
   assert(map != NULL, "map must be set");
@@ -59,6 +64,11 @@
   return frame(sender_sp());
 }
 
+frame frame::sender_for_deoptimizer_frame(RegisterMap *map) const
+{
+  return frame(sender_sp());
+}
+
 frame frame::sender(RegisterMap* map) const
 {
   // Default is not to follow arguments; the various
@@ -76,6 +86,9 @@
     return sender_for_compiled_frame(map);
   }
 
+  if (is_deoptimizer_frame())
+    return sender_for_deoptimizer_frame(map);
+
   Unimplemented();
 }
 
@@ -93,7 +106,14 @@
 
 void frame::patch_pc(Thread* thread, address pc)
 {
+#ifdef SHARK
+  // We borrow this call to set the thread pointer in the interpreter
+  // state; the hook to set up deoptimized frames isn't supplied it.
+  assert(pc == NULL, "should be");
+  get_interpreterState()->set_thread((JavaThread *) thread);
+#else
   Unimplemented();
+#endif // SHARK
 }
 
 bool frame::safe_for_sender(JavaThread *thread)
@@ -118,7 +138,11 @@
 
 int frame::frame_size() const
 {
-  Unimplemented();
+#ifdef PRODUCT
+  ShouldNotCallThis();
+#else
+  return 0; // make javaVFrame::print_value work
+#endif // PRODUCT
 }
 
 intptr_t* frame::interpreter_frame_tos_at(jint offset) const

--- a/ports/hotspot/src/cpu/zero/vm/frame_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/frame_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -41,7 +41,11 @@
   // accessors for the instance variables
   intptr_t* fp() const
   {
-    Unimplemented();
+#ifdef PRODUCT
+    ShouldNotCallThis();
+#else
+    return (intptr_t *) -1; // make frame::print_value_on work
+#endif // !PRODUCT
   }
 
 #ifdef CC_INTERP
@@ -56,16 +60,19 @@
 
   const EntryFrame *zero_entryframe() const
   {
-    assert(zeroframe()->is_entry_frame(), "must be");
-    return (EntryFrame *) zeroframe();
+    return zeroframe()->as_entry_frame();
   }
   const InterpreterFrame *zero_interpreterframe() const
   {
-    assert(zeroframe()->is_interpreter_frame(), "must be");
-    return (InterpreterFrame *) zeroframe();
+    return zeroframe()->as_interpreter_frame();
   }
   const SharkFrame *zero_sharkframe() const
   {
-    assert(zeroframe()->is_shark_frame(), "must be");
-    return (SharkFrame *) zeroframe();
+    return zeroframe()->as_shark_frame();
   }
+
+ public:
+  bool is_deoptimizer_frame() const;
+
+ public:
+  frame sender_for_deoptimizer_frame(RegisterMap* map) const;  

--- a/ports/hotspot/src/cpu/zero/vm/frame_zero.inline.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/frame_zero.inline.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -26,6 +26,7 @@
 #include <entryFrame_zero.hpp>
 #include <interpreterFrame_zero.hpp>
 #include <sharkFrame_zero.hpp>
+#include <deoptimizerFrame_zero.hpp>
 
 // Constructors
 
@@ -56,6 +57,11 @@
     _cb = CodeCache::find_blob(pc());
     break;
 
+  case ZeroFrame::DEOPTIMIZER_FRAME:
+    _pc = NULL;
+    _cb = NULL;
+    break;
+
   default:
     ShouldNotReachHere();
   }
@@ -162,5 +168,8 @@
 
 inline intptr_t* frame::unextended_sp() const
 {
-  return zero_sharkframe()->unextended_sp();
+  if (zeroframe()->is_shark_frame())
+    return zero_sharkframe()->unextended_sp();
+  else
+    return (intptr_t *) -1;
 }

--- a/ports/hotspot/src/cpu/zero/vm/interpreterFrame_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/interpreterFrame_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -40,6 +40,7 @@
 
 class InterpreterFrame : public ZeroFrame {
   friend class ZeroStackPrinter;
+  friend class AbstractInterpreter;
 
  private:
   InterpreterFrame() : ZeroFrame()
@@ -56,9 +57,11 @@
   };
 
  public:
-  static InterpreterFrame *build(ZeroStack*       stack,
-                                 const methodOop  method,
-                                 JavaThread*      thread);
+  static InterpreterFrame *build(ZeroStack*      stack,
+                                 const methodOop method,
+                                 JavaThread*     thread);
+  static InterpreterFrame *build(ZeroStack* stack, int size);
+
  public:
   interpreterState interpreter_state() const
   {

--- a/ports/hotspot/src/cpu/zero/vm/interpreter_zero.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/interpreter_zero.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -54,11 +54,21 @@
                                          int callee_locals,
                                          bool is_top_frame)
 {
-  Unimplemented();
+  return layout_activation(method, 
+                           tempcount,
+                           popframe_extra_args,
+                           moncount,
+                           callee_param_count,
+                           callee_locals,
+                           (frame*) NULL,
+                           (frame*) NULL,
+                           is_top_frame);
 }
 
 void Deoptimization::unwind_callee_save_values(frame* f,
                                                vframeArray* vframe_array)
 {
+#ifndef SHARK
   Unimplemented();
+#endif // !SHARK
 }

--- a/ports/hotspot/src/cpu/zero/vm/nativeInst_zero.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/nativeInst_zero.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 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/_nativeInst_zero.cpp.incl"
+
+// This method is called by nmethod::make_not_entrant_or_zombie to
+// insert a jump to SharedRuntime::get_handle_wrong_method_stub()
+// (dest) at the start of a compiled method (verified_entry) to avoid
+// a race where a method is invoked while being made non-entrant.
+//
+// In Shark, verified_entry is a pointer to a SharkEntry.  We can
+// handle this simply by changing it's entry point to point at the
+// interpreter.  This only works because the interpreter and Shark
+// calling conventions are the same.
+
+void NativeJump::patch_verified_entry(address entry,
+                                      address verified_entry,
+                                      address dest)
+{
+#ifdef SHARK
+  assert(dest == SharedRuntime::get_handle_wrong_method_stub(), "should be");
+
+#ifdef CC_INTERP
+  ((ZeroEntry*) verified_entry)->set_entry_point(CppInterpreter::normal_entry);
+#else
+  Unimplemented();
+#endif // CC_INTERP  
+#else
+  Unimplemented();
+#endif // SHARK
+}

--- a/ports/hotspot/src/cpu/zero/vm/nativeInst_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/nativeInst_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -189,9 +189,7 @@
 
   static void patch_verified_entry(address entry,
                                    address verified_entry,
-                                   address dest) {
-    Unimplemented();
-  }
+                                   address dest);
 };
 
 inline NativeJump* nativeJump_at(address address)

--- a/ports/hotspot/src/cpu/zero/vm/sharedRuntime_zero.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/sharedRuntime_zero.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -69,7 +69,11 @@
 
 int Deoptimization::last_frame_adjust(int callee_parameters, int callee_locals)
 {
+#ifdef SHARK
+  return 0;
+#else
   Unimplemented();
+#endif // SHARK
 }
 
 uint SharedRuntime::out_preserve_stack_slots()

--- a/ports/hotspot/src/cpu/zero/vm/sharkFrame_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/sharkFrame_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -31,6 +31,7 @@
 // | monitor m-1        |
 // |  ...               |
 // | monitor 0          |
+// | exception          |
 // | method             |
 // | unextended_sp      |
 // | pc                 |
@@ -54,6 +55,7 @@
     pc_off = jf_header_words,
     unextended_sp_off,
     method_off,
+    exception_off,
     header_words
   };
 

--- a/ports/hotspot/src/cpu/zero/vm/stackPrinter_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/stackPrinter_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -84,6 +84,9 @@
       case ZeroFrame::SHARK_FRAME:
         value = "SHARK_FRAME";
         break;
+      case ZeroFrame::DEOPTIMIZER_FRAME:
+        value = "DEOPTIMIZER_FRAME";
+        break;
       }
       break;
     }
@@ -101,11 +104,12 @@
       if (frame->is_interpreter_frame()) {
         interpreterState istate =
           ((InterpreterFrame *) frame)->interpreter_state();
-        intptr_t *monitor_base = (intptr_t *) istate->monitor_base();
+        bool is_valid = istate->self_link() == istate;
+        
         if (addr >= (intptr_t *) istate) {
           field = istate->name_of_field_at_address((address) addr);
           if (field) {
-            if (!strcmp(field, "_method")) {
+            if (is_valid && !strcmp(field, "_method")) {
               value = istate->method()->name_and_sig_as_C_string(_buf,_buflen);
               field = "istate->_method";
             }
@@ -119,66 +123,69 @@
             field = "(vtable for istate)";
           }
         }
-        else if (addr >= istate->stack_base() && addr < monitor_base) {
-          int monitor_size = frame::interpreter_frame_monitor_size();
-          int last_index =
-            (monitor_base - istate->stack_base()) / monitor_size - 1;
-          int index =
-            last_index - (addr - istate->stack_base()) / monitor_size;
-          intptr_t monitor = (intptr_t) (istate->monitor_base() - 1 - index);
-          intptr_t offset = (intptr_t) addr - monitor;
-          
-          if (offset == BasicObjectLock::obj_offset_in_bytes()) {
-            snprintf(_buf, _buflen, "monitor[%d]->_obj", index);
-            field = _buf;
-          }
-          else if (offset ==  BasicObjectLock::lock_offset_in_bytes()) {
-            snprintf(_buf, _buflen, "monitor[%d]->_lock", index);
-            field = _buf;
+        else if (is_valid) {
+          intptr_t *monitor_base = (intptr_t *) istate->monitor_base();
+          if (addr >= istate->stack_base() && addr < monitor_base) {
+            int monitor_size = frame::interpreter_frame_monitor_size();
+            int last_index =
+              (monitor_base - istate->stack_base()) / monitor_size - 1;
+            int index =
+              last_index - (addr - istate->stack_base()) / monitor_size;
+            intptr_t monitor = (intptr_t) (istate->monitor_base() - 1 - index);
+            intptr_t offset = (intptr_t) addr - monitor;
+            
+            if (offset == BasicObjectLock::obj_offset_in_bytes()) {
+              snprintf(_buf, _buflen, "monitor[%d]->_obj", index);
+              field = _buf;
+            }
+            else if (offset ==  BasicObjectLock::lock_offset_in_bytes()) {
+              snprintf(_buf, _buflen, "monitor[%d]->_lock", index);
+              field = _buf;
+            }
           }
-        }
-        else if (addr < istate->stack_base()) {
-          if (istate->method()->is_native()) {
-            address hA = istate->method()->signature_handler();
-            if (hA != NULL) {
-              if (hA != (address) InterpreterRuntime::slow_signature_handler) {
-                InterpreterRuntime::SignatureHandler *handler =
-                  InterpreterRuntime::SignatureHandler::from_handlerAddr(hA);
-
-                intptr_t *params =
-                  istate->stack_base() - handler->argument_count();
-
-                if (addr >= params) {
-                  int param = addr - params;
-                  const char *desc = "";
-                  if (param == 0)
-                    desc = " (JNIEnv)";
-                  else if (param == 1) {
-                    if (istate->method()->is_static())
-                      desc = " (mirror)";
-                    else
-                      desc = " (this)";
+          else if (addr < istate->stack_base()) {
+            if (istate->method()->is_native()) {
+              address hA = istate->method()->signature_handler();
+              if (hA != NULL) {
+                if (hA != (address)InterpreterRuntime::slow_signature_handler){
+                  InterpreterRuntime::SignatureHandler *handler =
+                    InterpreterRuntime::SignatureHandler::from_handlerAddr(hA);
+  
+                  intptr_t *params =
+                    istate->stack_base() - handler->argument_count();
+  
+                  if (addr >= params) {
+                    int param = addr - params;
+                    const char *desc = "";
+                    if (param == 0)
+                      desc = " (JNIEnv)";
+                    else if (param == 1) {
+                      if (istate->method()->is_static())
+                        desc = " (mirror)";
+                      else
+                        desc = " (this)";
+                    }
+                    snprintf(_buf, _buflen, "parameter[%d]%s", param, desc);
+                    field = _buf;
                   }
-                  snprintf(_buf, _buflen, "parameter[%d]%s", param, desc);
-                  field = _buf;
-                }
-                else {
-                  for (int i = 0; i < handler->argument_count(); i++) {
-                    if (params[i] == (intptr_t) addr) {
-                      snprintf(_buf, _buflen, "unboxed parameter[%d]", i);
-                      field = _buf;
-                      break;
-                    }
-                  } 
+                  else {
+                    for (int i = 0; i < handler->argument_count(); i++) {
+                      if (params[i] == (intptr_t) addr) {
+                        snprintf(_buf, _buflen, "unboxed parameter[%d]", i);
+                        field = _buf;
+                        break;
+                      }
+                    } 
+                  }
                 }
               }
             }
-          }
-          else {
-            snprintf(_buf, _buflen, "%s[%d]",
-                     top_frame ? "stack_word" : "local",
-                     istate->stack_base() - addr - 1);
-            field = _buf;
+            else {
+              snprintf(_buf, _buflen, "%s[%d]",
+                       top_frame ? "stack_word" : "local",
+                       istate->stack_base() - addr - 1);
+              field = _buf;
+            }
           }
         }
       }
@@ -195,6 +202,9 @@
           if (method->is_oop())
             value = method->name_and_sig_as_C_string(_buf, _buflen);
         }
+        else if (word == SharkFrame::exception_off) {
+          field = "exception";
+        }
         else {
           SharkFrame *sf = (SharkFrame *) frame;
           intptr_t *monitor_base =

--- a/ports/hotspot/src/cpu/zero/vm/stack_zero.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/cpu/zero/vm/stack_zero.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -110,6 +110,12 @@
   } 
 };
 
+
+class EntryFrame;
+class InterpreterFrame;
+class SharkFrame;
+class DeoptimizerFrame;
+
 // 
 // |  ...               |
 // +--------------------+  ------------------
@@ -138,7 +144,8 @@
   enum FrameType {
     ENTRY_FRAME = 1,
     INTERPRETER_FRAME,
-    SHARK_FRAME
+    SHARK_FRAME,
+    DEOPTIMIZER_FRAME
   };
 
  protected:
@@ -179,8 +186,34 @@
   {
     return type() == SHARK_FRAME;
   }
-};
+
+  bool is_deoptimizer_frame() const
+  {
+    return type() == DEOPTIMIZER_FRAME;
+  }
+
+ public:
+  EntryFrame *as_entry_frame() const
+  {
+    assert(is_entry_frame(), "should be");
+    return (EntryFrame *) this;
+  }
 
-class EntryFrame;
-class InterpreterFrame;
-class SharkFrame;
+  InterpreterFrame *as_interpreter_frame() const
+  {
+    assert(is_interpreter_frame(), "should be");
+    return (InterpreterFrame *) this;
+  }
+
+  SharkFrame *as_shark_frame() const
+  {
+    assert(is_shark_frame(), "should be");
+    return (SharkFrame *) this;
+  }
+
+  DeoptimizerFrame *as_deoptimizer_frame() const
+  {
+    assert(is_deoptimizer_frame(), "should be");
+    return (DeoptimizerFrame *) this;
+  }
+};

--- a/ports/hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -47,7 +47,14 @@
   // Must never look like an address returned by reserve_memory,
   // even in its subfields (as defined by the CPU immediate fields,
   // if the CPU splits constants across multiple instructions).
-  Unimplemented();
+#ifdef SPARC
+  // On SPARC, 0 != %hi(any real address), because there is no
+  // allocation in the first 1Kb of the virtual address space.
+  return (char *) 0;
+#else
+  // This is the value for x86; works pretty well for PPC too.
+  return (char *) -1;
+#endif // SPARC
 }
 
 void os::initialize_thread()

--- a/ports/hotspot/src/share/vm/includeDB_shark	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/share/vm/includeDB_shark	Tue Sep 30 08:42:10 2008 -0400
@@ -50,7 +50,7 @@
 
 compileBroker.cpp                       sharkCompiler.hpp
 
-disassembler_<arch>.cpp                 llvmHeaders.hpp
+disassembler_<arch>.cpp                 sharkEntry.hpp
 
 globals.hpp                             shark_globals_<arch>.hpp
 
@@ -74,10 +74,11 @@
 sharkBlock.cpp                          shark_globals.hpp
 sharkBlock.cpp                          sharkBlock.hpp
 sharkBlock.cpp                          sharkBuilder.hpp
+sharkBlock.cpp                          sharkBytecodeTracer.hpp
 sharkBlock.cpp                          sharkConstantPool.hpp
 sharkBlock.cpp                          sharkRuntime.hpp
 sharkBlock.cpp                          sharkState.inline.hpp
-sharkBlock.cpp                          sharkValue.hpp
+sharkBlock.cpp                          sharkValue.inline.hpp
 
 sharkBlock.hpp                          allocation.hpp
 sharkBlock.hpp                          bytecodes.hpp
@@ -89,7 +90,7 @@
 sharkBlock.hpp                          sharkFunction.hpp
 sharkBlock.hpp                          sharkMonitor.hpp
 sharkBlock.hpp                          sharkState.hpp
-sharkBlock.hpp                          sharkValue.hpp
+sharkBlock.hpp                          sharkValue.inline.hpp
 
 sharkBuilder.cpp                        ciMethod.hpp
 sharkBuilder.cpp                        debug.hpp
@@ -110,7 +111,28 @@
 sharkBuilder.hpp                        llvmHeaders.hpp
 sharkBuilder.hpp                        sizes.hpp
 sharkBuilder.hpp                        sharkType.hpp
-sharkBuilder.hpp                        sharkValue.hpp
+sharkBuilder.hpp                        sharkValue.inline.hpp
+
+sharkBytecodeTracer.cpp                 sharkBytecodeTracer.hpp
+sharkBytecodeTracer.cpp                 sharkState.inline.hpp
+sharkBytecodeTracer.cpp                 sharkValue.hpp
+
+sharkBytecodeTracer.hpp                 allocation.hpp
+sharkBytecodeTracer.hpp                 llvmHeaders.hpp
+sharkBytecodeTracer.hpp                 sharkState.hpp
+
+sharkCacheDecache.cpp                   ciMethod.hpp
+sharkCacheDecache.cpp                   debugInfoRec.hpp
+sharkCacheDecache.cpp                   sharkBuilder.hpp
+sharkCacheDecache.cpp                   sharkCacheDecache.hpp
+sharkCacheDecache.cpp                   sharkFunction.hpp
+sharkCacheDecache.cpp                   sharkState.inline.hpp
+
+sharkCacheDecache.hpp                   ciMethod.hpp
+sharkCacheDecache.hpp                   debugInfoRec.hpp
+sharkCacheDecache.hpp                   sharkBuilder.hpp
+sharkCacheDecache.hpp                   sharkFunction.hpp
+sharkCacheDecache.hpp                   sharkStateScanner.hpp
 
 sharkCompiler.cpp                       ciEnv.hpp
 sharkCompiler.cpp                       ciMethod.hpp
@@ -145,7 +167,7 @@
 sharkConstantPool.cpp                   sharkRuntime.hpp
 sharkConstantPool.cpp                   sharkState.inline.hpp
 sharkConstantPool.cpp                   sharkType.hpp
-sharkConstantPool.cpp                   sharkValue.hpp
+sharkConstantPool.cpp                   sharkValue.inline.hpp
 
 sharkConstantPool.hpp                   allocation.hpp
 sharkConstantPool.hpp                   llvmHeaders.hpp
@@ -175,14 +197,19 @@
 sharkFunction.hpp                       llvmHeaders.hpp
 sharkFunction.hpp                       sharkBuilder.hpp
 
+sharkMonitor.cpp                        llvmHeaders.hpp
+sharkMonitor.cpp                        sharkBlock.hpp
 sharkMonitor.cpp                        sharkMonitor.hpp
-sharkMonitor.cpp                        llvmHeaders.hpp
+sharkMonitor.cpp                        sharkRuntime.hpp
+sharkMonitor.cpp                        sharkState.inline.hpp
 
 sharkMonitor.hpp                        allocation.hpp
 sharkMonitor.hpp                        llvmHeaders.hpp
 sharkMonitor.hpp                        sharkBuilder.hpp
 sharkMonitor.hpp                        sharkFunction.hpp
 
+sharkRuntime.cpp                        biasedLocking.hpp
+sharkRuntime.cpp                        deoptimization.hpp
 sharkRuntime.cpp                        llvmHeaders.hpp
 sharkRuntime.cpp                        klassOop.hpp
 sharkRuntime.cpp                        sharkBuilder.hpp
@@ -203,14 +230,24 @@
 sharkState.cpp                          sharkBuilder.hpp
 sharkState.cpp                          sharkState.inline.hpp
 sharkState.cpp                          sharkType.hpp
-sharkState.cpp                          sharkValue.hpp
+sharkState.cpp                          sharkValue.inline.hpp
 
 sharkState.hpp                          allocation.hpp
-sharkState.hpp                          sharkValue.hpp
+sharkState.hpp                          sharkBuilder.hpp
+sharkState.hpp                          sharkFunction.hpp
+sharkState.hpp                          sharkValue.inline.hpp
 sharkState.hpp                          vmreg.hpp
 
 sharkState.inline.hpp                   sharkBlock.hpp
 sharkState.inline.hpp                   sharkState.hpp
+sharkState.inline.hpp                   sharkCacheDecache.hpp
+
+sharkStateScanner.cpp                   sharkState.inline.hpp
+sharkStateScanner.cpp                   sharkStateScanner.hpp
+
+sharkStateScanner.hpp                   allocation.hpp
+sharkStateScanner.hpp                   llvmHeaders.hpp
+sharkStateScanner.hpp                   sharkFunction.hpp
 
 sharkType.cpp                           arrayOop.hpp
 sharkType.cpp                           globalDefinitions.hpp
@@ -228,3 +265,7 @@
 sharkValue.hpp                          ciType.hpp
 sharkValue.hpp                          llvmHeaders.hpp
 sharkValue.hpp                          sharkType.hpp
+
+sharkValue.inline.hpp                   ciType.hpp
+sharkValue.inline.hpp                   llvmHeaders.hpp
+sharkValue.inline.hpp                   sharkValue.hpp

--- a/ports/hotspot/src/share/vm/shark/sharkBlock.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBlock.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -26,19 +26,77 @@
 #include "incls/_precompiled.incl"
 #include "incls/_sharkBlock.cpp.incl"
 #include "ciArrayKlass.hpp" // XXX fuck you makeDeps
+#include "ciObjArrayKlass.hpp" // XXX likewise
 
 using namespace llvm;
 
+void SharkBlock::enter(SharkBlock* predecessor, bool is_exception)
+{
+  // This block requires phis:
+  //  - if it is entered more than once
+  //  - if it is an exception handler, because in which
+  //    case we assume it's entered more than once.
+  //  - if the predecessor will be compiled after this
+  //    block, in which case we can't simple propagate
+  //    the state forward.
+  if (!needs_phis() &&
+      (entered() ||
+       is_exception ||
+       (predecessor && predecessor->index() >= index())))
+    _needs_phis = true;
+
+  // Recurse into the tree
+  if (!entered()) {
+    _entered = true;
+
+    if (!has_trap()) {
+      for (int i = 0; i < num_successors(); i++) {
+        successor(i)->enter(this, false);
+      }
+      for (int i = 0; i < num_exceptions(); i++) {
+        exception(i)->enter(this, true);
+      }
+    }
+  }
+}
+  
 void SharkBlock::initialize()
 {
   char name[28];
   snprintf(name, sizeof(name),
            "bci_%d%s",
-           ciblock()->start(),
-           ciblock()->is_private_copy() ? "_private_copy" : "");
+           start(), is_private_copy() ? "_private_copy" : "");
   _entry_block = function()->CreateBlock(name);
 }
 
+void SharkBlock::acquire_method_lock()
+{
+  Value *object;
+  if (target()->is_static()) {
+    SharkConstantPool constants(this);
+    object = constants.java_mirror();
+  }
+  else {
+    object = local(0)->jobject_value();
+  }
+  iter()->force_bci(start()); // for the decache
+  function()->monitor(0)->acquire(this, object);
+  check_pending_exception(false);
+}
+
+void SharkBlock::release_method_lock()
+{
+  function()->monitor(0)->release(this);
+
+  // We neither need nor want to check for pending exceptions here.
+  // This method is only called by handle_return, which copes with
+  // them implicitly:
+  //  - if a value is being returned then we just carry on as normal;
+  //    the caller will see the pending exception and handle it.
+  //  - if an exception is being thrown then that exception takes
+  //    priority and ours will be ignored.
+}
+
 void SharkBlock::parse()
 {
   SharkValue *a, *b, *c, *d;
@@ -46,25 +104,30 @@
 
   builder()->SetInsertPoint(entry_block());
 
-  if (never_entered()) {
-    NOT_PRODUCT(warning("skipping unentered block"));
-    builder()->CreateShouldNotReachHere(__FILE__, __LINE__);
-    builder()->CreateUnreachable();
-    return;
-  }
-
-  if (ciblock()->has_trap()) {
-    current_state()->decache();
-    builder()->CreateDump(LLVMValue::jint_constant(start()));
-    builder()->CreateUnimplemented(__FILE__, __LINE__);
-    builder()->CreateUnreachable();
+  if (has_trap()) {
+    current_state()->decache_for_trap();
+    builder()->CreateCall2(
+      SharkRuntime::uncommon_trap(),
+      thread(),
+      LLVMValue::jint_constant(trap_index()));
+    builder()->CreateRetVoid();
     return;
   }
 
   iter()->reset_to_bci(start());
+  bool successors_done = false;
   while (iter()->next() != ciBytecodeStream::EOBC() && bci() < limit()) {
     NOT_PRODUCT(a = b = c = d = NULL);    
 
+    if (TraceBytecodes) {
+      Value *tos, *tos2;
+      SharkBytecodeTracer::decode(builder(), current_state(), &tos, &tos2);
+      call_vm(
+        SharkRuntime::trace_bytecode(),
+        LLVMValue::jint_constant(bci()),
+        tos, tos2);
+    }
+    
     if (SharkTraceBytecodes)
       tty->print_cr("%4d: %s", bci(), Bytecodes::name(bc()));
     
@@ -99,13 +162,16 @@
         break;
 
       case Bytecodes::_tableswitch:
-        len = iter()->get_int_table(2) - iter()->get_int_table(1) + 1;
-        for (i = 0; i < len + 3; i++) {
-          if (i != 1 && i != 2) {
-            if (iter()->get_dest_table(i) <= bci()) {
-              add_safepoint();
-              break;
-            }
+      case Bytecodes::_lookupswitch:
+        if (switch_default_dest() <= bci()) {
+          add_safepoint();
+          break;
+        }
+        len = switch_table_length();
+        for (i = 0; i < len; i++) {
+          if (switch_dest(i) <= bci()) {
+            add_safepoint();
+            break;
           }
         }
         break;
@@ -302,130 +368,68 @@
       break;
 
     case Bytecodes::_pop:
-      pop_and_assert_one_word();
+      xpop();
       break;
     case Bytecodes::_pop2:
-      if (stack(0)->is_two_word()) {
-        pop_and_assert_two_word();
-      }
-      else {
-        pop_and_assert_one_word();
-        pop_and_assert_one_word();
-      }
+      xpop();
+      xpop();
       break;
     case Bytecodes::_swap: 
-      a = pop_and_assert_one_word();
-      b = pop_and_assert_one_word();
-      push(a);
-      push(b);
+      a = xpop();
+      b = xpop();
+      xpush(a);
+      xpush(b);
       break;  
     case Bytecodes::_dup:
-      a = pop_and_assert_one_word();
-      push(a);
-      push(a);
+      a = xpop();
+      xpush(a);
+      xpush(a);
       break;
     case Bytecodes::_dup_x1: 
-      a = pop_and_assert_one_word();
-      b = pop_and_assert_one_word();
-      push(a);
-      push(b);
-      push(a);
+      a = xpop();
+      b = xpop();
+      xpush(a);
+      xpush(b);
+      xpush(a);
       break;
     case Bytecodes::_dup_x2: 
-      if (stack(1)->is_two_word()) {
-        a = pop_and_assert_one_word();
-        b = pop_and_assert_two_word();
-        push(a);
-        push(b);
-        push(a);
-      }
-      else {
-        a = pop_and_assert_one_word();
-        b = pop_and_assert_one_word();
-        c = pop_and_assert_one_word();
-        push(a);
-        push(c);
-        push(b);
-        push(a);
-      }
+      a = xpop();
+      b = xpop();
+      c = xpop();
+      xpush(a);
+      xpush(c);
+      xpush(b);
+      xpush(a);
       break;
     case Bytecodes::_dup2: 
-      if (stack(0)->is_two_word()) {
-        a = pop_and_assert_two_word();
-        push(a);
-        push(a);
-      }
-      else {
-        a = pop_and_assert_one_word();
-        b = pop_and_assert_one_word();
-        push(b);
-        push(a);
-        push(b);
-        push(a);
-      }
+      a = xpop();
+      b = xpop();
+      xpush(b);
+      xpush(a);
+      xpush(b);
+      xpush(a);
       break;
     case Bytecodes::_dup2_x1:
-      if (stack(0)->is_two_word()) {
-        a = pop_and_assert_two_word();
-        b = pop_and_assert_one_word();
-        push(a);
-        push(b);
-        push(a);
-      }
-      else {
-        a = pop_and_assert_one_word();
-        b = pop_and_assert_one_word();
-        c = pop_and_assert_one_word();
-        push(b);
-        push(a);
-        push(c);
-        push(b);
-        push(a);
-      }
+      a = xpop();
+      b = xpop();
+      c = xpop();
+      xpush(b);
+      xpush(a);
+      xpush(c);
+      xpush(b);
+      xpush(a);
       break;
     case Bytecodes::_dup2_x2:
-      if (stack(0)->is_one_word()) {
-        if (stack(2)->is_one_word()) {
-          a = pop_and_assert_one_word();
-          b = pop_and_assert_one_word();
-          c = pop_and_assert_one_word();
-          d = pop_and_assert_one_word();
-          push(b);
-          push(a);
-          push(d);
-          push(c);
-          push(b);
-          push(a);
-        }
-        else {
-          a = pop_and_assert_one_word();
-          b = pop_and_assert_one_word();
-          c = pop_and_assert_two_word();
-          push(b);
-          push(a);
-          push(c);
-          push(b);
-          push(a);
-        }
-      }
-      else {
-        if (stack(1)->is_one_word()) {
-          a = pop_and_assert_two_word();
-          b = pop_and_assert_one_word();
-          c = pop_and_assert_one_word();
-          push(a);
-          push(c);
-          push(b);
-          push(a);
-        }
-        else {
-          a = pop_and_assert_two_word();
-          b = pop_and_assert_two_word();
-          push(a);
-          push(b);
-          push(a);
-        }
-      }
+      a = xpop();
+      b = xpop();
+      c = xpop();
+      d = xpop();
+      xpush(b);
+      xpush(a);
+      xpush(d);
+      xpush(c);
+      xpush(b);
+      xpush(a);
       break;
 
     case Bytecodes::_arraylength:
@@ -672,6 +676,19 @@
       do_lcmp();
       break;
 
+    case Bytecodes::_fcmpl:
+      do_fcmp(false, false);
+      break;
+    case Bytecodes::_fcmpg:
+      do_fcmp(false, true);
+      break;
+    case Bytecodes::_dcmpl:
+      do_fcmp(true, false);
+      break;
+    case Bytecodes::_dcmpg:
+      do_fcmp(true, true);
+      break;
+
     case Bytecodes::_i2l:
       push(SharkValue::create_jlong(
         builder()->CreateIntCast(
@@ -779,8 +796,7 @@
       break;
 
     case Bytecodes::_athrow:
-      builder()->CreateUnimplemented(__FILE__, __LINE__);
-      builder()->CreateUnreachable();
+      do_athrow();
       break;
 
     case Bytecodes::_goto:
@@ -788,6 +804,18 @@
       builder()->CreateBr(successor(ciTypeFlow::GOTO_TARGET)->entry_block());
       break;
 
+    case Bytecodes::_jsr:
+    case Bytecodes::_jsr_w:
+      push(SharkValue::create_returnAddress(iter()->next_bci()));
+      builder()->CreateBr(successor(ciTypeFlow::GOTO_TARGET)->entry_block());
+      break;
+
+    case Bytecodes::_ret:
+      assert(local(iter()->get_index())->returnAddress_value() ==
+             successor(ciTypeFlow::GOTO_TARGET)->start(), "should be");
+      builder()->CreateBr(successor(ciTypeFlow::GOTO_TARGET)->entry_block());
+      break;
+
     case Bytecodes::_ifnull:
       do_if(ICmpInst::ICMP_EQ, SharkValue::null(), pop());
       break;
@@ -838,7 +866,9 @@
       break;
 
     case Bytecodes::_tableswitch:
-      do_tableswitch();
+    case Bytecodes::_lookupswitch:
+      do_switch();
+      successors_done = true;
       break;
 
     case Bytecodes::_invokestatic:
@@ -859,6 +889,12 @@
     case Bytecodes::_newarray:
       do_newarray();
       break;
+    case Bytecodes::_anewarray:
+      do_anewarray();
+      break;
+    case Bytecodes::_multianewarray:
+      do_multianewarray();
+      break;
 
     case Bytecodes::_monitorenter:
       do_monitorenter();
@@ -868,25 +904,18 @@
       break;
 
     default:
-      {
-        const char *code = Bytecodes::name(bc());
-        int buflen = 19 + strlen(code) + 1;
-        char *buf = (char *) function()->env()->arena()->Amalloc(buflen);
-        snprintf(buf, buflen, "Unhandled bytecode %s", code);
-        record_method_not_compilable(buf);
-      }
+      ShouldNotReachHere();
     }
-
-    if (failing())
-      return;
   }
 
   if (falls_through()) {
     builder()->CreateBr(successor(ciTypeFlow::FALL_THROUGH)->entry_block());
   }
 
-  for (int i = 0; i < num_successors(); i++)
-    successor(i)->add_incoming(current_state());
+  if (!successors_done) {
+    for (int i = 0; i < num_successors(); i++)
+      successor(i)->add_incoming(current_state());
+  }
 }
 
 SharkBlock* SharkBlock::bci_successor(int bci) const
@@ -910,6 +939,9 @@
 
   Value *a, *b;
   switch (value->basic_type()) {
+  case T_BYTE:
+  case T_CHAR:
+  case T_SHORT:
   case T_INT:
     a = value->jint_value();
     b = LLVMValue::jint_constant(0);
@@ -924,14 +956,25 @@
     b = LLVMValue::LLVMValue::null();
     break;
   default:
+    tty->print_cr("Unhandled type %s", type2name(value->basic_type()));
     ShouldNotReachHere();
   }
 
   builder()->CreateCondBr(builder()->CreateICmpNE(a, b), not_zero, zero);
 
   builder()->SetInsertPoint(zero);
-  builder()->CreateUnimplemented(__FILE__, __LINE__);
-  builder()->CreateUnreachable();
+  SharkTrackingState *saved_state = current_state()->copy();
+  if (value->is_jobject()) {
+    call_vm_nocheck(
+      SharkRuntime::throw_NullPointerException(),
+      LLVMValue::intptr_constant((intptr_t) __FILE__),
+      LLVMValue::jint_constant(__LINE__));
+  }
+  else {
+    builder()->CreateUnimplemented(__FILE__, __LINE__);
+  } 
+  handle_exception(function()->CreateGetPendingException());
+  set_current_state(saved_state);  
 
   builder()->SetInsertPoint(not_zero);
 
@@ -944,39 +987,130 @@
   BasicBlock *in_bounds     = function()->CreateBlock("in_bounds");
 
   Value *length = builder()->CreateArrayLength(array->jarray_value());
+  // we use an unsigned comparison to catch negative values
   builder()->CreateCondBr(
-    builder()->CreateICmpSLT(index->jint_value(), length),
+    builder()->CreateICmpULT(index->jint_value(), length),
     in_bounds, out_of_bounds);
 
   builder()->SetInsertPoint(out_of_bounds);
-  builder()->CreateUnimplemented(__FILE__, __LINE__);
-  builder()->CreateUnreachable();
+  SharkTrackingState *saved_state = current_state()->copy();
+  call_vm_nocheck(
+    SharkRuntime::throw_ArrayIndexOutOfBoundsException(),
+    LLVMValue::intptr_constant((intptr_t) __FILE__),
+    LLVMValue::jint_constant(__LINE__),
+    index->jint_value());
+  handle_exception(function()->CreateGetPendingException());
+  set_current_state(saved_state);  
 
   builder()->SetInsertPoint(in_bounds);
 }
 
-void SharkBlock::check_pending_exception()
+void SharkBlock::check_pending_exception(bool attempt_catch)
 {
   BasicBlock *exception    = function()->CreateBlock("exception");
   BasicBlock *no_exception = function()->CreateBlock("no_exception");
 
-  Value *pending_exception = builder()->CreateValueOfStructEntry(
-    thread(), Thread::pending_exception_offset(),
-    SharkType::jobject_type(), "pending_exception");
+  Value *pending_exception_addr = function()->pending_exception_address();
+  Value *pending_exception = builder()->CreateLoad(
+    pending_exception_addr, "pending_exception");
 
   builder()->CreateCondBr(
     builder()->CreateICmpEQ(pending_exception, LLVMValue::null()),
     no_exception, exception);
 
   builder()->SetInsertPoint(exception);
-  builder()->CreateUnimplemented(__FILE__, __LINE__);
-  builder()->CreateUnreachable();
+  builder()->CreateStore(LLVMValue::null(), pending_exception_addr);
+  SharkTrackingState *saved_state = current_state()->copy();
+  handle_exception(pending_exception, attempt_catch);
+  set_current_state(saved_state);
 
   builder()->SetInsertPoint(no_exception);
 }
 
+void SharkBlock::handle_exception(Value* exception, bool attempt_catch)
+{
+  if (attempt_catch && num_exceptions() != 0) {
+    // Clear the stack and push the exception onto it.
+    // We do this now to protect it across the VM call
+    // we may be about to make.
+    while (xstack_depth())
+      pop();
+    push(SharkValue::create_jobject(exception));
+
+    int *indexes = NEW_RESOURCE_ARRAY(int, num_exceptions());
+    bool has_catch_all = false;
+
+    ciExceptionHandlerStream eh_iter(target(), bci());
+    for (int i = 0; i < num_exceptions(); i++, eh_iter.next()) {
+      ciExceptionHandler* handler = eh_iter.handler();
+
+      if (handler->is_catch_all()) {
+        assert(i == num_exceptions() - 1, "catch-all should be last");
+        has_catch_all = true;
+      }
+      else {
+        indexes[i] = handler->catch_klass_index();
+      }
+    }
+
+    int num_options = num_exceptions();
+    if (has_catch_all)
+      num_options--;
+
+    // Drop into the runtime if there are non-catch-all options
+    if (num_options > 0) {
+      Value *options = builder()->CreateAlloca(
+        ArrayType::get(SharkType::jint_type(), num_options),
+        LLVMValue::jint_constant(1));
+
+      for (int i = 0; i < num_options; i++)
+        builder()->CreateStore(
+          LLVMValue::jint_constant(indexes[i]),
+          builder()->CreateStructGEP(options, i));
+
+      Value *index = call_vm_nocheck(
+        SharkRuntime::find_exception_handler(),
+        builder()->CreateStructGEP(options, 0),
+        LLVMValue::jint_constant(num_options));
+      check_pending_exception(false);
+
+      // Jump to the exception handler, if found
+      BasicBlock *no_handler = function()->CreateBlock("no_handler");
+      SwitchInst *switchinst = builder()->CreateSwitch(
+        index, no_handler, num_options);
+
+      for (int i = 0; i < num_options; i++) {
+        SharkBlock* handler = this->exception(i);
+
+        switchinst->addCase(
+          LLVMValue::jint_constant(i),
+          handler->entry_block());
+
+        handler->add_incoming(current_state());
+      }
+
+      builder()->SetInsertPoint(no_handler);
+    }
+
+    // No specific handler exists, but maybe there's a catch-all
+    if (has_catch_all) {
+      SharkBlock* handler = this->exception(num_options);
+
+      builder()->CreateBr(handler->entry_block());
+      handler->add_incoming(current_state());
+      return;
+    }
+  }
+
+  // No exception handler was found; unwind and return
+  handle_return(T_VOID, exception);
+}
+
 void SharkBlock::add_safepoint()
 {
+  BasicBlock *orig_block = builder()->GetInsertBlock();
+  SharkState *orig_state = current_state()->copy();
+
   BasicBlock *do_safepoint = function()->CreateBlock("do_safepoint");
   BasicBlock *safepointed  = function()->CreateBlock("safepointed");
 
@@ -994,42 +1128,80 @@
     do_safepoint, safepointed);
 
   builder()->SetInsertPoint(do_safepoint);
-  // XXX decache_state
-  // XXX call whatever
-  // XXX cache_state
-  // XXX  THEN MERGE (need phis...)
-  // XXX (if it's call_VM then call_VM should do the decache/cache)
-  // XXX shouldn't ever need a fixup_after_potential_safepoint
-  // XXX since anything that might safepoint needs a decache/cache
-  builder()->CreateUnimplemented(__FILE__, __LINE__);
-  builder()->CreateUnreachable();
+  call_vm(SharkRuntime::safepoint());
+  BasicBlock *safepointed_block = builder()->GetInsertBlock();  
+  builder()->CreateBr(safepointed);
 
   builder()->SetInsertPoint(safepointed);
+  current_state()->merge(orig_state, orig_block, safepointed_block);
 }
 
-CallInst* SharkBlock::call_vm_base(Constant* callee,
-                                   Value**   args_start,
-                                   Value**   args_end)
+void SharkBlock::handle_return(BasicType type, Value* exception)
 {
-  // Decache the state
-  current_state()->decache();
+  assert (exception == NULL || type == T_VOID, "exception OR result, please");
+
+  if (exception)
+    builder()->CreateStore(exception, function()->exception_slot());
+
+  release_locked_monitors();
+  if (target()->is_synchronized())
+    release_method_lock();
+  
+  if (exception) {
+    exception = builder()->CreateLoad(function()->exception_slot());
+    builder()->CreateStore(exception, function()->pending_exception_address());
+  }
 
-  // Set up the Java frame anchor  
-  function()->set_last_Java_frame();
+  Value *result_addr = function()->CreatePopFrame(type2size[type]);
+  if (type != T_VOID) {
+    SharkValue *result = pop();
+
+#ifdef ASSERT
+    switch (result->basic_type()) {
+    case T_BOOLEAN:
+    case T_BYTE:
+    case T_CHAR:
+    case T_SHORT:
+      assert(type == T_INT, "type mismatch");
+      break;
+
+    case T_ARRAY:
+      assert(type == T_OBJECT, "type mismatch");
+      break;
 
-  // Make the call
-  CallInst *result = builder()->CreateCall(callee, args_start, args_end);
+    default:
+      assert(result->basic_type() == type, "type mismatch");
+    }
+#endif // ASSERT
 
-  // Clear the frame anchor
-  function()->reset_last_Java_frame();
+    builder()->CreateStore(
+      result->generic_value(),
+      builder()->CreateIntToPtr(
+        result_addr,
+        PointerType::getUnqual(SharkType::to_stackType(type))));
+  }
+
+  builder()->CreateRetVoid();
+}
 
-  // Recache the state
-  current_state()->cache();
+void SharkBlock::release_locked_monitors()
+{
+  int base = target()->is_synchronized();
+  for (int i = function()->monitor_count() - 1; i >= base; i--) {
+    BasicBlock *locked   = function()->CreateBlock("locked");
+    BasicBlock *unlocked = function()->CreateBlock("unlocked");
 
-  // Check for pending exceptions  
-  check_pending_exception();
+    Value *object = function()->monitor(i)->object();
+    builder()->CreateCondBr(
+      builder()->CreateICmpNE(object, LLVMValue::null()),
+      locked, unlocked);
+    
+    builder()->SetInsertPoint(locked);
+    builder()->CreateUnimplemented(__FILE__, __LINE__);
+    builder()->CreateUnreachable();
 
-  return result;
+    builder()->SetInsertPoint(unlocked);
+  }
 }
 
 void SharkBlock::do_ldc()
@@ -1038,8 +1210,7 @@
   if (value == NULL) {
     SharkConstantPool constants(this);
 
-    BasicBlock *string     = function()->CreateBlock("string");
-    BasicBlock *klass      = function()->CreateBlock("klass");
+    BasicBlock *resolved   = function()->CreateBlock("resolved");
     BasicBlock *unresolved = function()->CreateBlock("unresolved");
     BasicBlock *unknown    = function()->CreateBlock("unknown");
     BasicBlock *done       = function()->CreateBlock("done");
@@ -1049,9 +1220,9 @@
       unknown, 5);
 
     switchinst->addCase(
-      LLVMValue::jbyte_constant(JVM_CONSTANT_String), string);
+      LLVMValue::jbyte_constant(JVM_CONSTANT_String), resolved);
     switchinst->addCase(
-      LLVMValue::jbyte_constant(JVM_CONSTANT_Class), klass);
+      LLVMValue::jbyte_constant(JVM_CONSTANT_Class), resolved);
     switchinst->addCase(
       LLVMValue::jbyte_constant(JVM_CONSTANT_UnresolvedString), unresolved);
     switchinst->addCase(
@@ -1060,13 +1231,8 @@
       LLVMValue::jbyte_constant(JVM_CONSTANT_UnresolvedClassInError),
       unresolved);
 
-    builder()->SetInsertPoint(string);
-    Value *string_value = constants.object_at(iter()->get_constant_index());
-    builder()->CreateBr(done);
-
-    builder()->SetInsertPoint(klass);
-    builder()->CreateUnimplemented(__FILE__, __LINE__);
-    Value *klass_value = LLVMValue::null();
+    builder()->SetInsertPoint(resolved);
+    Value *resolved_value = constants.object_at(iter()->get_constant_index());
     builder()->CreateBr(done);
 
     builder()->SetInsertPoint(unresolved);
@@ -1080,8 +1246,7 @@
 
     builder()->SetInsertPoint(done);
     PHINode *phi = builder()->CreatePHI(SharkType::jobject_type(), "constant");
-    phi->addIncoming(string_value, string);
-    phi->addIncoming(klass_value, klass);
+    phi->addIncoming(resolved_value, resolved);
     phi->addIncoming(unresolved_value, unresolved);
     value = SharkValue::create_jobject(phi);
   }
@@ -1103,7 +1268,9 @@
 
   assert(array->type()->is_array_klass(), "should be");
   ciType *element_type = ((ciArrayKlass *) array->type())->element_type();
-  assert(element_type->basic_type() == basic_type, "type mismatch");
+  assert((element_type->basic_type() == T_BOOLEAN && basic_type == T_BYTE) ||
+         (element_type->basic_type() == T_ARRAY && basic_type == T_OBJECT) ||
+         (element_type->basic_type() == basic_type), "type mismatch");
 
   check_null(array);
   check_bounds(array, index);
@@ -1117,7 +1284,6 @@
     value = builder()->CreateIntCast(value, stack_type, basic_type != T_CHAR);
 
   switch (basic_type) {
-  case T_BOOLEAN:
   case T_BYTE:
   case T_CHAR:
   case T_SHORT:
@@ -1138,7 +1304,7 @@
     break;
     
   case T_OBJECT:
-    push(SharkValue::create_jobject(value));
+    push(SharkValue::create_generic(element_type, value));
     break;
 
   default:
@@ -1155,7 +1321,9 @@
 
   assert(array->type()->is_array_klass(), "should be");
   ciType *element_type = ((ciArrayKlass *) array->type())->element_type();
-  assert(element_type->basic_type() == basic_type, "type mismatch");
+  assert((element_type->basic_type() == T_BOOLEAN && basic_type == T_BYTE) ||
+         (element_type->basic_type() == T_ARRAY && basic_type == T_OBJECT) ||
+         (element_type->basic_type() == basic_type), "type mismatch");
 
   check_null(array);
   check_bounds(array, index);
@@ -1338,12 +1506,8 @@
       if (!field->type()->is_primitive_type())
         builder()->CreateUpdateBarrierSet(oopDesc::bs(), addr);
 
-      if (field->is_volatile()) {
+      if (field->is_volatile())
         builder()->CreateMemoryBarrier(SharkBuilder::BARRIER_STORELOAD);
-#ifdef PPC
-        record_method_not_compilable("Missing memory barrier");
-#endif // PPC
-      }
     }
   }
 
@@ -1383,43 +1547,51 @@
   push(SharkValue::create_jint(result));
 }
 
-void SharkBlock::do_return(BasicType basic_type)
+void SharkBlock::do_fcmp(bool is_double, bool unordered_is_greater)
 {
-  add_safepoint();
-
-  if (target()->is_synchronized())
-    function()->monitor(0)->release();
-
-  Value *result_addr = function()->CreatePopFrame(type2size[basic_type]);
-  if (basic_type != T_VOID) {
-    SharkValue *result = pop();
-
-#ifdef ASSERT
-    switch (result->basic_type()) {
-    case T_BOOLEAN:
-    case T_BYTE:
-    case T_CHAR:
-    case T_SHORT:
-      assert(basic_type == T_INT, "type mismatch");
-      break;
-
-    case T_ARRAY:
-      assert(basic_type == T_OBJECT, "type mismatch");
-      break;
-
-    default:
-      assert(result->basic_type() == basic_type, "type mismatch");
-    }
-#endif // ASSERT
-
-    builder()->CreateStore(
-      result->generic_value(),
-      builder()->CreateIntToPtr(
-        result_addr,
-        PointerType::getUnqual(SharkType::to_stackType(basic_type))));
+  Value *a, *b;
+  if (is_double) {
+    b = pop()->jdouble_value();
+    a = pop()->jdouble_value();
+  }
+  else {
+    b = pop()->jfloat_value();
+    a = pop()->jfloat_value();
   }
 
-  builder()->CreateRetVoid();
+  BasicBlock *ordered = function()->CreateBlock("ordered");
+  BasicBlock *ge      = function()->CreateBlock("fcmp_ge");
+  BasicBlock *lt      = function()->CreateBlock("fcmp_lt");
+  BasicBlock *eq      = function()->CreateBlock("fcmp_eq");
+  BasicBlock *gt      = function()->CreateBlock("fcmp_gt");
+  BasicBlock *done    = function()->CreateBlock("done");
+
+  builder()->CreateCondBr(
+    builder()->CreateFCmpUNO(a, b),
+    unordered_is_greater ? gt : lt, ordered);
+
+  builder()->SetInsertPoint(ordered);
+  builder()->CreateCondBr(builder()->CreateFCmpULT(a, b), lt, ge);
+
+  builder()->SetInsertPoint(ge);
+  builder()->CreateCondBr(builder()->CreateFCmpUGT(a, b), gt, eq);
+
+  builder()->SetInsertPoint(lt);
+  builder()->CreateBr(done);
+
+  builder()->SetInsertPoint(gt);
+  builder()->CreateBr(done);
+
+  builder()->SetInsertPoint(eq);
+  builder()->CreateBr(done);
+
+  builder()->SetInsertPoint(done);
+  PHINode *result = builder()->CreatePHI(SharkType::jint_type(), "result");
+  result->addIncoming(LLVMValue::jint_constant(-1), lt);
+  result->addIncoming(LLVMValue::jint_constant(0),  eq);
+  result->addIncoming(LLVMValue::jint_constant(1),  gt);
+
+  push(SharkValue::create_jint(result));
 }
 
 void SharkBlock::do_if(ICmpInst::Predicate p, SharkValue *b, SharkValue *a)
@@ -1440,21 +1612,306 @@
     successor(ciTypeFlow::IF_NOT_TAKEN)->entry_block());
 }
 
-void SharkBlock::do_tableswitch()
+int SharkBlock::switch_default_dest()
+{
+  return iter()->get_dest_table(0);
+}
+
+int SharkBlock::switch_table_length()
+{
+  switch(bc()) {
+  case Bytecodes::_tableswitch:
+    return iter()->get_int_table(2) - iter()->get_int_table(1) + 1;
+
+  case Bytecodes::_lookupswitch:
+    return iter()->get_int_table(1);
+
+  default:
+    ShouldNotReachHere();
+  } 
+}
+
+int SharkBlock::switch_key(int i)
 {
-  int low  = iter()->get_int_table(1);
-  int high = iter()->get_int_table(2);
-  int len  = high - low + 1;
+  switch(bc()) {
+  case Bytecodes::_tableswitch:
+    return iter()->get_int_table(1) + i;
+
+  case Bytecodes::_lookupswitch:
+    return iter()->get_int_table(2 + 2 * i);
+
+  default:
+    ShouldNotReachHere();
+  } 
+}
 
+int SharkBlock::switch_dest(int i)
+{
+  switch(bc()) {
+  case Bytecodes::_tableswitch:
+    return iter()->get_dest_table(i + 3);
+
+  case Bytecodes::_lookupswitch:
+    return iter()->get_dest_table(2 + 2 * i + 1);
+
+  default:
+    ShouldNotReachHere();
+  } 
+}
+
+void SharkBlock::do_switch()
+{
+  int len = switch_table_length();
+
+  SharkBlock *dest_block = successor(ciTypeFlow::SWITCH_DEFAULT);
   SwitchInst *switchinst = builder()->CreateSwitch(
-    pop()->jint_value(),
-    successor(ciTypeFlow::SWITCH_DEFAULT)->entry_block(),
-    len);
+    pop()->jint_value(), dest_block->entry_block(), len);
+  dest_block->add_incoming(current_state());
 
   for (int i = 0; i < len; i++) {
-    switchinst->addCase(
-      LLVMValue::jint_constant(i + low),
-      bci_successor(iter()->get_dest_table(i + 3))->entry_block());
+    int dest_bci = switch_dest(i);
+    if (dest_bci != switch_default_dest()) {
+      dest_block = bci_successor(dest_bci);
+      switchinst->addCase(
+        LLVMValue::jint_constant(switch_key(i)),
+        dest_block->entry_block());
+      dest_block->add_incoming(current_state());      
+    }
+  }
+}
+
+Value* SharkBlock::get_basic_callee(Value *cache)
+{
+  return builder()->CreateValueOfStructEntry(
+    cache, ConstantPoolCacheEntry::f1_offset(),
+    SharkType::methodOop_type(),
+    "callee");
+}
+
+Value* SharkBlock::get_virtual_callee(Value *cache, SharkValue *receiver)
+{
+  BasicBlock *final      = function()->CreateBlock("final");
+  BasicBlock *not_final  = function()->CreateBlock("not_final");
+  BasicBlock *got_callee = function()->CreateBlock("got_callee");
+
+  Value *flags = builder()->CreateValueOfStructEntry(
+    cache, ConstantPoolCacheEntry::flags_offset(),
+    SharkType::intptr_type(),
+    "flags");
+
+  const int mask = 1 << ConstantPoolCacheEntry::vfinalMethod;
+  builder()->CreateCondBr(
+    builder()->CreateICmpNE(
+      builder()->CreateAnd(flags, LLVMValue::intptr_constant(mask)),
+      LLVMValue::intptr_constant(0)),
+    final, not_final);
+
+  // For final methods f2 is the actual address of the method
+  builder()->SetInsertPoint(final);
+  Value *final_callee = builder()->CreateValueOfStructEntry(
+    cache, ConstantPoolCacheEntry::f2_offset(),
+    SharkType::methodOop_type(),
+    "final_callee");
+  builder()->CreateBr(got_callee);
+
+  // For non-final methods f2 is the index into the vtable
+  builder()->SetInsertPoint(not_final);
+  Value *klass = builder()->CreateValueOfStructEntry(
+    receiver->jobject_value(),
+    in_ByteSize(oopDesc::klass_offset_in_bytes()),
+    SharkType::jobject_type(),
+    "klass");
+
+  Value *index = builder()->CreateValueOfStructEntry(
+    cache, ConstantPoolCacheEntry::f2_offset(),
+    SharkType::intptr_type(),
+    "index");
+
+  Value *nonfinal_callee = builder()->CreateLoad(
+    builder()->CreateArrayAddress(
+      klass,
+      SharkType::methodOop_type(),
+      vtableEntry::size() * wordSize,
+      in_ByteSize(instanceKlass::vtable_start_offset() * wordSize),
+      index),
+    "nonfinal_callee");
+  builder()->CreateBr(got_callee);
+
+  builder()->SetInsertPoint(got_callee);
+  PHINode *callee = builder()->CreatePHI(
+    SharkType::methodOop_type(), "callee");
+  callee->addIncoming(final_callee, final);
+  callee->addIncoming(nonfinal_callee, not_final);
+
+  return callee;
+}
+
+Value* SharkBlock::get_interface_callee(Value *cache, SharkValue *receiver)
+{
+  BasicBlock *hacky      = function()->CreateBlock("hacky");
+  BasicBlock *normal     = function()->CreateBlock("normal");
+  BasicBlock *loop       = function()->CreateBlock("loop");
+  BasicBlock *got_null   = function()->CreateBlock("got_null");
+  BasicBlock *not_null   = function()->CreateBlock("not_null");
+  BasicBlock *next       = function()->CreateBlock("next");
+  BasicBlock *got_entry  = function()->CreateBlock("got_entry");
+  BasicBlock *got_callee = function()->CreateBlock("got_callee");
+
+  Value *flags = builder()->CreateValueOfStructEntry(
+    cache, ConstantPoolCacheEntry::flags_offset(),
+    SharkType::intptr_type(),
+    "flags");
+
+  const int mask = 1 << ConstantPoolCacheEntry::methodInterface;
+  builder()->CreateCondBr(
+    builder()->CreateICmpNE(
+      builder()->CreateAnd(flags, LLVMValue::intptr_constant(mask)),
+      LLVMValue::intptr_constant(0)),
+    hacky, normal);
+
+  // Workaround for the case where we encounter an invokeinterface,
+  // but should really have an invokevirtual since the resolved
+  // method is a virtual method in java.lang.Object. This is a
+  // corner case in the spec but is presumably legal, and while
+  // javac does not generate this code there's no reason it could
+  // not be produced by a compliant java compiler.  See
+  // cpCacheOop.cpp for more details.
+  builder()->SetInsertPoint(hacky);
+  Value *hacky_callee = get_virtual_callee(cache, receiver);
+  BasicBlock *got_hacky = builder()->GetInsertBlock();
+  builder()->CreateBr(got_callee);
+
+  // Locate the receiver's itable
+  builder()->SetInsertPoint(normal);
+  Value *object_klass = builder()->CreateValueOfStructEntry(
+    receiver->jobject_value(), in_ByteSize(oopDesc::klass_offset_in_bytes()),
+    SharkType::jobject_type(),
+    "object_klass");
+
+  Value *vtable_start = builder()->CreateAdd(
+    builder()->CreatePtrToInt(object_klass, SharkType::intptr_type()),
+    LLVMValue::intptr_constant(
+      instanceKlass::vtable_start_offset() * HeapWordSize),
+    "vtable_start");
+
+  Value *vtable_length = builder()->CreateValueOfStructEntry(
+    object_klass,
+    in_ByteSize(instanceKlass::vtable_length_offset() * HeapWordSize),
+    SharkType::jint_type(),
+    "vtable_length");
+
+  bool needs_aligning = HeapWordsPerLong > 1;
+  const char *itable_start_name = "itable_start";
+  Value *itable_start = builder()->CreateAdd(
+    vtable_start,
+    builder()->CreateShl(
+      vtable_length,
+      LLVMValue::jint_constant(exact_log2(vtableEntry::size() * wordSize))),
+    needs_aligning ? "" : itable_start_name);
+  if (needs_aligning)
+    itable_start = builder()->CreateAlign(
+      itable_start, BytesPerLong, itable_start_name);
+
+  // Locate this interface's entry in the table
+  Value *iklass = builder()->CreateValueOfStructEntry(
+    cache, ConstantPoolCacheEntry::f1_offset(),
+    SharkType::jobject_type(),
+    "iklass");
+
+  builder()->CreateBr(loop);
+  builder()->SetInsertPoint(loop);
+  PHINode *itable_entry_addr = builder()->CreatePHI(
+    SharkType::intptr_type(), "itable_entry_addr");
+  itable_entry_addr->addIncoming(itable_start, normal);
+
+  Value *itable_entry = builder()->CreateIntToPtr(
+    itable_entry_addr, SharkType::itableOffsetEntry_type(), "itable_entry");
+
+  Value *itable_iklass = builder()->CreateValueOfStructEntry(
+    itable_entry,
+    in_ByteSize(itableOffsetEntry::interface_offset_in_bytes()),
+    SharkType::jobject_type(),
+    "itable_iklass");
+
+  builder()->CreateCondBr(
+    builder()->CreateICmpEQ(itable_iklass, LLVMValue::null()),
+    got_null, not_null);
+
+  // A null entry means that the class doesn't implement the
+  // interface, and wasn't the same as the class checked when
+  // the interface was resolved.
+  builder()->SetInsertPoint(got_null);
+  builder()->CreateUnimplemented(__FILE__, __LINE__);
+  builder()->CreateUnreachable();
+                          
+  builder()->SetInsertPoint(not_null);
+  builder()->CreateCondBr(
+    builder()->CreateICmpEQ(itable_iklass, iklass),
+    got_entry, next);
+
+  builder()->SetInsertPoint(next);
+  Value *next_entry = builder()->CreateAdd(
+    itable_entry_addr,
+    LLVMValue::intptr_constant(itableOffsetEntry::size() * wordSize));
+  builder()->CreateBr(loop);
+  itable_entry_addr->addIncoming(next_entry, next);
+
+  // Locate the method pointer
+  builder()->SetInsertPoint(got_entry);
+  Value *offset = builder()->CreateValueOfStructEntry(
+    itable_entry,
+    in_ByteSize(itableOffsetEntry::offset_offset_in_bytes()),
+    SharkType::jint_type(),
+    "offset");
+
+  Value *index = builder()->CreateValueOfStructEntry(
+    cache, ConstantPoolCacheEntry::f2_offset(),
+    SharkType::intptr_type(),
+    "index");
+
+  Value *normal_callee = builder()->CreateLoad(
+    builder()->CreateIntToPtr(
+      builder()->CreateAdd(
+        builder()->CreateAdd(
+          builder()->CreateAdd(
+            builder()->CreatePtrToInt(
+              object_klass, SharkType::intptr_type()),
+            offset),
+          builder()->CreateShl(
+            index,
+            LLVMValue::jint_constant(
+              exact_log2(itableMethodEntry::size() * wordSize)))),
+        LLVMValue::intptr_constant(
+          itableMethodEntry::method_offset_in_bytes())),
+      PointerType::getUnqual(SharkType::methodOop_type())),
+    "normal_callee");
+  BasicBlock *got_normal = builder()->GetInsertBlock();
+  builder()->CreateBr(got_callee);
+
+  builder()->SetInsertPoint(got_callee);
+  PHINode *callee = builder()->CreatePHI(
+    SharkType::methodOop_type(), "callee");
+  callee->addIncoming(hacky_callee, got_hacky);
+  callee->addIncoming(normal_callee, got_normal);
+
+  return callee;
+} 
+
+Value* SharkBlock::get_callee(Value *cache, SharkValue *receiver)
+{
+  switch (bc()) {
+  case Bytecodes::_invokestatic:
+  case Bytecodes::_invokespecial:
+    return get_basic_callee(cache);
+
+  case Bytecodes::_invokevirtual:
+    return get_virtual_callee(cache, receiver);
+
+  case Bytecodes::_invokeinterface:
+    return get_interface_callee(cache, receiver);
+
+  default:
+    ShouldNotReachHere();
   }
 }
 
@@ -1467,223 +1924,14 @@
   // Find the receiver in the stack
   SharkValue *receiver = NULL;
   if (bc() != Bytecodes::_invokestatic) {
-    int shark_slot = 0, java_slot = 0;
-    while (java_slot < method->arg_size() - 1)
-      java_slot += stack(shark_slot++)->type()->size();
-    receiver = stack(shark_slot);
+    receiver = xstack(method->arg_size() - 1);
     check_null(receiver);
   }
 
   // Find the method we are calling
-  Value *callee = NULL;
   SharkConstantPool constants(this);
   Value *cache = constants.cache_entry_at(iter()->get_method_index());
-
-  if (bc() == Bytecodes::_invokevirtual) {
-    BasicBlock *final     = function()->CreateBlock("final");
-    BasicBlock *not_final = function()->CreateBlock("not_final");
-    BasicBlock *invoke    = function()->CreateBlock("invoke");
-
-    Value *flags = builder()->CreateValueOfStructEntry(
-      cache, ConstantPoolCacheEntry::flags_offset(),
-      SharkType::intptr_type(),
-      "flags");
-
-    const int mask = 1 << ConstantPoolCacheEntry::vfinalMethod;
-    builder()->CreateCondBr(
-      builder()->CreateICmpNE(
-        builder()->CreateAnd(flags, LLVMValue::intptr_constant(mask)),
-        LLVMValue::intptr_constant(0)),
-      final, not_final);
-
-    // For final methods f2 is the actual address of the method
-    builder()->SetInsertPoint(final);
-    Value *final_callee = builder()->CreateValueOfStructEntry(
-      cache, ConstantPoolCacheEntry::f2_offset(),
-      SharkType::methodOop_type(),
-      "final_callee");
-    builder()->CreateBr(invoke);
-
-    // For non-final methods f2 is the index into the vtable
-    builder()->SetInsertPoint(not_final);
-    Value *klass = builder()->CreateValueOfStructEntry(
-      receiver->jobject_value(),
-      in_ByteSize(oopDesc::klass_offset_in_bytes()),
-      SharkType::jobject_type(),
-      "klass");
-
-    Value *index = builder()->CreateValueOfStructEntry(
-      cache, ConstantPoolCacheEntry::f2_offset(),
-      SharkType::intptr_type(),
-      "index");
-
-    Value *nonfinal_callee = builder()->CreateLoad(
-      builder()->CreateArrayAddress(
-        klass,
-        SharkType::methodOop_type(),
-        vtableEntry::size() * wordSize,
-        in_ByteSize(instanceKlass::vtable_start_offset() * wordSize),
-        index),
-      "nonfinal_callee");
-    builder()->CreateBr(invoke);
-
-    builder()->SetInsertPoint(invoke);
-    callee = builder()->CreatePHI(SharkType::methodOop_type(), "callee");
-    ((PHINode *) callee)->addIncoming(final_callee, final);
-    ((PHINode *) callee)->addIncoming(nonfinal_callee, not_final);
-  }
-  else if (bc() == Bytecodes::_invokeinterface) {
-    BasicBlock *hacky     = function()->CreateBlock("hacky");
-    BasicBlock *normal    = function()->CreateBlock("normal");
-    BasicBlock *loop      = function()->CreateBlock("loop");
-    BasicBlock *got_null  = function()->CreateBlock("got_null");
-    BasicBlock *not_null  = function()->CreateBlock("not_null");
-    BasicBlock *next      = function()->CreateBlock("next");
-    BasicBlock *got_entry = function()->CreateBlock("got_entry");
-    BasicBlock *invoke    = function()->CreateBlock("invoke");
-
-    Value *flags = builder()->CreateValueOfStructEntry(
-      cache, ConstantPoolCacheEntry::flags_offset(),
-      SharkType::intptr_type(),
-      "flags");
-
-    const int mask = 1 << ConstantPoolCacheEntry::methodInterface;
-    builder()->CreateCondBr(
-      builder()->CreateICmpNE(
-        builder()->CreateAnd(flags, LLVMValue::intptr_constant(mask)),
-        LLVMValue::intptr_constant(0)),
-      hacky, normal);
-
-    // Workaround for the case where we encounter an invokeinterface,
-    // but should really have an invokevirtual since the resolved
-    // method is a virtual method in java.lang.Object. This is a
-    // corner case in the spec but is presumably legal, and while
-    // javac does not generate this code there's no reason it could
-    // not be produced by a compliant java compiler.  See
-    // cpCacheOop.cpp for more details.
-    builder()->SetInsertPoint(hacky);
-    builder()->CreateUnimplemented(__FILE__, __LINE__);
-    Value *hacky_callee =
-      ConstantPointerNull::get(SharkType::methodOop_type());
-    builder()->CreateBr(invoke);
-
-    // Locate the receiver's itable
-    builder()->SetInsertPoint(normal);
-    Value *object_klass = builder()->CreateValueOfStructEntry(
-      receiver->jobject_value(), in_ByteSize(oopDesc::klass_offset_in_bytes()),
-      SharkType::jobject_type(),
-      "object_klass");
-
-    Value *vtable_start = builder()->CreateAdd(
-      builder()->CreatePtrToInt(object_klass, SharkType::intptr_type()),
-      LLVMValue::intptr_constant(
-        instanceKlass::vtable_start_offset() * HeapWordSize),
-      "vtable_start");
-
-    Value *vtable_length = builder()->CreateValueOfStructEntry(
-      object_klass,
-      in_ByteSize(instanceKlass::vtable_length_offset() * HeapWordSize),
-      SharkType::jint_type(),
-      "vtable_length");
-
-    bool needs_aligning = HeapWordsPerLong > 1;
-    const char *itable_start_name = "itable_start";
-    Value *itable_start = builder()->CreateAdd(
-      vtable_start,
-      builder()->CreateShl(
-        vtable_length,
-        LLVMValue::jint_constant(exact_log2(vtableEntry::size() * wordSize))),
-      needs_aligning ? "" : itable_start_name);
-    if (needs_aligning)
-      itable_start = builder()->CreateAlign(
-        itable_start, BytesPerLong, itable_start_name);
-
-    // Locate this interface's entry in the table
-    Value *iklass = builder()->CreateValueOfStructEntry(
-      cache, ConstantPoolCacheEntry::f1_offset(),
-      SharkType::jobject_type(),
-      "iklass");
-
-    builder()->CreateBr(loop);
-    builder()->SetInsertPoint(loop);
-    PHINode *itable_entry_addr = builder()->CreatePHI(
-      SharkType::intptr_type(), "itable_entry_addr");
-    itable_entry_addr->addIncoming(itable_start, normal);
-
-    Value *itable_entry = builder()->CreateIntToPtr(
-      itable_entry_addr, SharkType::itableOffsetEntry_type(), "itable_entry");
-
-    Value *itable_iklass = builder()->CreateValueOfStructEntry(
-      itable_entry,
-      in_ByteSize(itableOffsetEntry::interface_offset_in_bytes()),
-      SharkType::jobject_type(),
-      "itable_iklass");
-
-    builder()->CreateCondBr(
-      builder()->CreateICmpEQ(itable_iklass, LLVMValue::null()),
-      got_null, not_null);
-
-    // A null entry means that the class doesn't implement the
-    // interface, and wasn't the same as the class checked when
-    // the interface was resolved.
-    builder()->SetInsertPoint(got_null);
-    builder()->CreateUnimplemented(__FILE__, __LINE__);
-    builder()->CreateUnreachable();
-                            
-    builder()->SetInsertPoint(not_null);
-    builder()->CreateCondBr(
-      builder()->CreateICmpEQ(itable_iklass, iklass),
-      got_entry, next);
-
-    builder()->SetInsertPoint(next);
-    Value *next_entry = builder()->CreateAdd(
-      itable_entry_addr,
-      LLVMValue::intptr_constant(itableOffsetEntry::size() * wordSize));
-    builder()->CreateBr(loop);
-    itable_entry_addr->addIncoming(next_entry, next);
-
-    // Locate the method pointer
-    builder()->SetInsertPoint(got_entry);
-    Value *offset = builder()->CreateValueOfStructEntry(
-      itable_entry,
-      in_ByteSize(itableOffsetEntry::offset_offset_in_bytes()),
-      SharkType::jint_type(),
-      "offset");
-
-    Value *index = builder()->CreateValueOfStructEntry(
-      cache, ConstantPoolCacheEntry::f2_offset(),
-      SharkType::intptr_type(),
-      "index");
-
-    Value *normal_callee = builder()->CreateLoad(
-      builder()->CreateIntToPtr(
-        builder()->CreateAdd(
-          builder()->CreateAdd(
-            builder()->CreateAdd(
-              builder()->CreatePtrToInt(
-                object_klass, SharkType::intptr_type()),
-              offset),
-            builder()->CreateShl(
-              index,
-              LLVMValue::jint_constant(
-                exact_log2(itableMethodEntry::size() * wordSize)))),
-          LLVMValue::intptr_constant(
-            itableMethodEntry::method_offset_in_bytes())),
-        PointerType::getUnqual(SharkType::methodOop_type())),
-      "normal_callee");
-    builder()->CreateBr(invoke);
-
-    builder()->SetInsertPoint(invoke);
-    callee = builder()->CreatePHI(SharkType::methodOop_type(), "callee");
-    ((PHINode *) callee)->addIncoming(hacky_callee, hacky);
-    ((PHINode *) callee)->addIncoming(normal_callee, got_entry);    
-  }
-  else {
-    callee = builder()->CreateValueOfStructEntry(
-      cache, ConstantPoolCacheEntry::f1_offset(),
-      SharkType::methodOop_type(),
-      "callee");
-  }
+  Value *callee = get_callee(cache, receiver);
 
   Value *base_pc = builder()->CreateValueOfStructEntry(
     callee, methodOopDesc::from_interpreted_offset(),
@@ -1700,9 +1948,9 @@
     "entry_point");
 
   // Make the call
-  current_state()->decache(method);
+  current_state()->decache_for_Java_call(method);
   builder()->CreateCall3(entry_point, callee, base_pc, thread());
-  current_state()->cache(method);
+  current_state()->cache_after_Java_call(method);
 
   // Check for pending exceptions
   check_pending_exception();
@@ -1710,23 +1958,45 @@
 
 void SharkBlock::do_instance_check()
 {
+  // Leave the object on the stack until after all the VM calls
+  assert(xstack(0)->is_jobject(), "should be");
+  
+  ciKlass *klass = NULL;
+  if (bc() == Bytecodes::_checkcast) {
+    bool will_link;
+    klass = iter()->get_klass(will_link);
+    if (!will_link) {
+      // XXX why is this not typeflow's responsibility?
+      NOT_PRODUCT(warning("unresolved checkcast in %s", function()->name()));
+      klass = (ciKlass *) xstack(0)->type();
+    }
+  }
+
   BasicBlock *not_null      = function()->CreateBlock("not_null");
-  BasicBlock *resolve       = function()->CreateBlock("resolve");
-  BasicBlock *resolved      = function()->CreateBlock("resolved");
+  BasicBlock *fast_path     = function()->CreateBlock("fast_path");
+  BasicBlock *slow_path     = function()->CreateBlock("slow_path");
+  BasicBlock *got_klass     = function()->CreateBlock("got_klass");
   BasicBlock *subtype_check = function()->CreateBlock("subtype_check");
-  BasicBlock *failure       = function()->CreateBlock("failure");
-  BasicBlock *success       = function()->CreateBlock("success");
+  BasicBlock *is_instance   = function()->CreateBlock("is_instance");
+  BasicBlock *not_instance  = function()->CreateBlock("not_instance");
+  BasicBlock *merge1        = function()->CreateBlock("merge1");
+  BasicBlock *merge2        = function()->CreateBlock("merge2");
 
-  SharkValue *sharkobject = pop();
-  Value *object = sharkobject->jobject_value();
+  enum InstanceCheckStates {
+    IC_IS_NULL,
+    IC_IS_INSTANCE,
+    IC_NOT_INSTANCE,
+  };
 
   // Null objects aren't instances of anything
   builder()->CreateCondBr(
-    builder()->CreateICmpEQ(object, LLVMValue::null()),
-    bc() == Bytecodes::_checkcast ? success : failure, not_null);
-  builder()->SetInsertPoint(not_null);
+    builder()->CreateICmpEQ(xstack(0)->jobject_value(), LLVMValue::null()),
+    merge2, not_null);
+  BasicBlock *null_block = builder()->GetInsertBlock();
+  SharkState *null_state = current_state()->copy();
 
   // Get the class we're checking against
+  builder()->SetInsertPoint(not_null);
   SharkConstantPool constants(this);
   Value *tag = constants.tag_at(iter()->get_klass_index());
   builder()->CreateCondBr(
@@ -1735,63 +2005,103 @@
         tag, LLVMValue::jbyte_constant(JVM_CONSTANT_UnresolvedClass)),
       builder()->CreateICmpEQ(
         tag, LLVMValue::jbyte_constant(JVM_CONSTANT_UnresolvedClassInError))),
-    resolve, resolved);
+    slow_path, fast_path);
+
+  // The fast path
+  builder()->SetInsertPoint(fast_path);
+  BasicBlock *fast_block = builder()->GetInsertBlock();
+  SharkState *fast_state = current_state()->copy();
+  Value *fast_klass = constants.object_at(iter()->get_klass_index());
+  builder()->CreateBr(got_klass);
 
-  // If the class is unresolved we must resolve it
-  builder()->SetInsertPoint(resolve);
-  builder()->CreateUnimplemented(__FILE__, __LINE__);
-  builder()->CreateUnreachable(); // XXX builder()->CreateBr(resolved);
+  // The slow path
+  builder()->SetInsertPoint(slow_path);
+  call_vm(
+    SharkRuntime::resolve_klass(),
+    LLVMValue::jint_constant(iter()->get_klass_index()));
+  Value *slow_klass = function()->CreateGetVMResult();
+  BasicBlock *slow_block = builder()->GetInsertBlock();  
+  builder()->CreateBr(got_klass);
 
-  builder()->SetInsertPoint(resolved);
-  Value *check_klass = constants.object_at(iter()->get_klass_index());
+  // We have the class to test against
+  builder()->SetInsertPoint(got_klass);
+  current_state()->merge(fast_state, fast_block, slow_block);
+  PHINode *check_klass = builder()->CreatePHI(
+    SharkType::jobject_type(), "check_klass");
+  check_klass->addIncoming(fast_klass, fast_block);
+  check_klass->addIncoming(slow_klass, slow_block);
 
   // Get the class of the object being tested
   Value *object_klass = builder()->CreateValueOfStructEntry(
-    object, in_ByteSize(oopDesc::klass_offset_in_bytes()),
+    xstack(0)->jobject_value(), in_ByteSize(oopDesc::klass_offset_in_bytes()),
     SharkType::jobject_type(),
     "object_klass");
 
   // Perform the check
   builder()->CreateCondBr(
     builder()->CreateICmpEQ(check_klass, object_klass),
-    success, subtype_check);
-  
+    is_instance, subtype_check);
+
   builder()->SetInsertPoint(subtype_check);
   builder()->CreateCondBr(
     builder()->CreateICmpNE(
       builder()->CreateCall2(
         SharkRuntime::is_subtype_of(), check_klass, object_klass),
       LLVMValue::jbyte_constant(0)),
-    success, failure);
+    is_instance, not_instance);
+
+  builder()->SetInsertPoint(is_instance);
+  builder()->CreateBr(merge1);
+
+  builder()->SetInsertPoint(not_instance);
+  builder()->CreateBr(merge1);
+
+  // First merge
+  builder()->SetInsertPoint(merge1);
+  PHINode *nonnull_result = builder()->CreatePHI(
+    SharkType::jint_type(), "nonnull_result");
+  nonnull_result->addIncoming(
+    LLVMValue::jint_constant(IC_IS_INSTANCE), is_instance);
+  nonnull_result->addIncoming(
+    LLVMValue::jint_constant(IC_NOT_INSTANCE), not_instance);
+  BasicBlock *nonnull_block = builder()->GetInsertBlock();
+  builder()->CreateBr(merge2);
+  
+  // Second merge
+  builder()->SetInsertPoint(merge2);
+  current_state()->merge(null_state, null_block, nonnull_block);
+  PHINode *result = builder()->CreatePHI(
+    SharkType::jint_type(), "result");
+  result->addIncoming(LLVMValue::jint_constant(IC_IS_NULL), null_block);
+  result->addIncoming(nonnull_result, nonnull_block);
+
+  // We can finally pop the object!
+  Value *object = pop()->jobject_value();
 
   // Handle the result
   if (bc() == Bytecodes::_checkcast) {
+    BasicBlock *failure = function()->CreateBlock("failure");
+    BasicBlock *success = function()->CreateBlock("success");
+
+    builder()->CreateCondBr(
+      builder()->CreateICmpNE(
+        result, LLVMValue::jint_constant(IC_NOT_INSTANCE)),
+      success, failure);
+
     builder()->SetInsertPoint(failure);
     builder()->CreateUnimplemented(__FILE__, __LINE__);
     builder()->CreateUnreachable();
 
     builder()->SetInsertPoint(success);
-    push(sharkobject);
-  }
-  else if (bc() == Bytecodes::_instanceof) {
-    BasicBlock *done = function()->CreateBlock("done");
-
-    builder()->SetInsertPoint(success);
-    builder()->CreateBr(done);
-
-    builder()->SetInsertPoint(failure);
-    builder()->CreateBr(done);
-
-    builder()->SetInsertPoint(done);
-    PHINode *result = builder()->CreatePHI(SharkType::jint_type(), "result");
-    result->addIncoming(LLVMValue::jint_constant(1), success);
-    result->addIncoming(LLVMValue::jint_constant(0), failure);
-
-    push(SharkValue::create_jint(result));
+    push(SharkValue::create_generic(klass, object));
   }
   else {
-    tty->print_cr("Unhandled bytecode %s", Bytecodes::name(bc()));
-    ShouldNotReachHere();
+    push(
+      SharkValue::create_jint(
+        builder()->CreateIntCast(
+          builder()->CreateICmpEQ(
+            result, LLVMValue::jint_constant(IC_IS_INSTANCE)),
+          SharkType::jint_type(), false)));
   }
 }
 
@@ -1801,11 +2111,13 @@
   ciInstanceKlass* klass = iter()->get_klass(will_link)->as_instance_klass();
   assert(will_link, "typeflow responsibility");
 
+  BasicBlock *tlab_alloc          = NULL;
   BasicBlock *got_tlab            = NULL;
   BasicBlock *heap_alloc          = NULL;
   BasicBlock *retry               = NULL;
   BasicBlock *got_heap            = NULL;
   BasicBlock *initialize          = NULL;
+  BasicBlock *got_fast            = NULL;
   BasicBlock *slow_alloc_and_init = NULL;
   BasicBlock *got_slow            = NULL;
   BasicBlock *push_object         = NULL;
@@ -1818,22 +2130,33 @@
   Value *slow_object = NULL;
   Value *object      = NULL;
 
+  SharkConstantPool constants(this);
+
   // The fast path
   if (!Klass::layout_helper_needs_slow_path(klass->layout_helper())) {
     if (UseTLAB) {
+      tlab_alloc        = function()->CreateBlock("tlab_alloc");
       got_tlab          = function()->CreateBlock("got_tlab");
-      heap_alloc        = function()->CreateBlock("heap_alloc");
     }
+    heap_alloc          = function()->CreateBlock("heap_alloc");
     retry               = function()->CreateBlock("retry");
     got_heap            = function()->CreateBlock("got_heap");
     initialize          = function()->CreateBlock("initialize");
     slow_alloc_and_init = function()->CreateBlock("slow_alloc_and_init");
     push_object         = function()->CreateBlock("push_object");
 
+    builder()->CreateCondBr(
+      builder()->CreateICmpEQ(
+        constants.tag_at(iter()->get_klass_index()),
+        LLVMValue::jbyte_constant(JVM_CONSTANT_Class)),
+      UseTLAB ? tlab_alloc : heap_alloc, slow_alloc_and_init);
+    
     size_t size_in_bytes = klass->size_helper() << LogHeapWordSize;
 
     // Thread local allocation
     if (UseTLAB) {
+      builder()->SetInsertPoint(tlab_alloc);
+
       Value *top_addr = builder()->CreateAddressOfStructEntry(
         thread(), Thread::tlab_top_offset(),
         PointerType::getUnqual(SharkType::intptr_type()),
@@ -1858,11 +2181,11 @@
 
       builder()->CreateStore(new_top, top_addr);
       builder()->CreateBr(initialize);
-      
-      builder()->SetInsertPoint(heap_alloc);
     }
 
     // Heap allocation
+    builder()->SetInsertPoint(heap_alloc);
+
     Value *top_addr = builder()->CreateIntToPtr(
       LLVMValue::intptr_constant((intptr_t) Universe::heap()->top_addr()),
       PointerType::getUnqual(SharkType::intptr_type()),
@@ -1935,9 +2258,9 @@
     builder()->CreateStore(LLVMValue::intptr_constant(mark), mark_addr);
 
     // Set the class
-    SharkConstantPool constants(this);
     Value *rtklass = constants.object_at(iter()->get_klass_index());
     builder()->CreateStore(rtklass, klass_addr);
+    got_fast = builder()->GetInsertBlock();
 
     builder()->CreateBr(push_object);
     builder()->SetInsertPoint(slow_alloc_and_init);
@@ -1945,10 +2268,9 @@
   }
 
   // The slow path
-  SharkConstantPool constants(this);
   call_vm(
     SharkRuntime::new_instance(),
-    constants.object_at(iter()->get_klass_index()));
+    LLVMValue::jint_constant(iter()->get_klass_index()));
   slow_object = function()->CreateGetVMResult();
   got_slow = builder()->GetInsertBlock();
 
@@ -1959,10 +2281,10 @@
   }
   if (fast_object) {
     PHINode *phi = builder()->CreatePHI(SharkType::jobject_type(), "object");
-    phi->addIncoming(fast_object, initialize);
+    phi->addIncoming(fast_object, got_fast);
     phi->addIncoming(slow_object, got_slow);
     object = phi;
-    current_state()->merge(fast_state, initialize, got_slow);
+    current_state()->merge(fast_state, got_fast, got_slow);
   }
   else {
     object = slow_object;
@@ -1989,6 +2311,66 @@
   push(result);
 }
 
+void SharkBlock::do_anewarray()
+{
+  bool will_link;
+  ciKlass *klass = iter()->get_klass(will_link);
+  assert(will_link, "typeflow responsibility");
+
+  ciObjArrayKlass *array_klass = ciObjArrayKlass::make(klass);
+  if (!array_klass->is_loaded()) {
+    Unimplemented();
+  }
+
+  call_vm(
+    SharkRuntime::anewarray(),
+    LLVMValue::jint_constant(iter()->get_klass_index()),
+    pop()->jint_value());
+
+  SharkValue *result = SharkValue::create_generic(
+    array_klass, function()->CreateGetVMResult());
+  result->set_zero_checked(true);
+  push(result);
+}
+
+void SharkBlock::do_multianewarray()
+{
+  bool will_link;
+  ciArrayKlass *array_klass = iter()->get_klass(will_link)->as_array_klass();
+  assert(will_link, "typeflow responsibility");
+
+  // The dimensions are stack values, so we use their slots for the
+  // dimensions array.  Note that we are storing them in the reverse
+  // of normal stack order.
+  int ndims = iter()->get_dimensions();
+
+  Value *dimensions = function()->CreateAddressOfFrameEntry(
+    function()->stack_slots_offset() + max_stack() - xstack_depth(),
+    ArrayType::get(SharkType::jint_type(), ndims),
+    "dimensions");
+
+  for (int i = 0; i < ndims; i++) {
+    builder()->CreateStore(
+      xstack(ndims - 1 - i)->jint_value(),
+      builder()->CreateStructGEP(dimensions, i));
+  }
+
+  call_vm(
+    SharkRuntime::multianewarray(),
+    LLVMValue::jint_constant(iter()->get_klass_index()),
+    LLVMValue::jint_constant(ndims),
+    builder()->CreateStructGEP(dimensions, 0));
+
+  // Now we can pop the dimensions off the stack
+  for (int i = 0; i < ndims; i++)
+    pop();
+
+  SharkValue *result = SharkValue::create_generic(
+    array_klass, function()->CreateGetVMResult());
+  result->set_zero_checked(true);
+  push(result);
+}
+
 void SharkBlock::do_monitorenter()
 {
   SharkValue *lockee = pop();
@@ -2033,7 +2415,8 @@
 
   // Acquire the lock
   builder()->SetInsertPoint(got_monitor);
-  monitor->acquire(object);
+  monitor->acquire(this, object);
+  check_pending_exception();
 }
 
 void SharkBlock::do_monitorexit()
@@ -2078,5 +2461,6 @@
 
   // Release the lock
   builder()->SetInsertPoint(got_monitor);
-  monitor->release();
+  monitor->release(this);
+  check_pending_exception();
 }

--- a/ports/hotspot/src/share/vm/shark/sharkBlock.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBlock.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -28,19 +28,15 @@
   SharkBlock(SharkFunction* function, ciTypeFlow::Block* ciblock)
     : _function(function),
       _ciblock(ciblock),
-      _num_predecessors(0),
-      _entered_backwards(false),
+      _entered(false),
+      _needs_phis(false),
       _entry_state(NULL),
-      _current_state(NULL)
-  { initialize(); }
-
- private:
-  void initialize();
+      _entry_block(NULL),
+      _current_state(NULL) {}
 
  private:
   SharkFunction*     _function;
   ciTypeFlow::Block* _ciblock;
-  llvm::BasicBlock*  _entry_block;
 
  public:
   SharkFunction* function() const
@@ -51,24 +47,12 @@
   {
     return _ciblock;
   }
-  llvm::BasicBlock* entry_block() const
-  {
-    return _entry_block;
-  }
 
  public:
   SharkBuilder* builder() const
   {
     return function()->builder();
   }
-  bool failing() const
-  {
-    return function()->failing();
-  }
-  void record_method_not_compilable(const char* reason) const
-  {
-    function()->record_method_not_compilable(reason);
-  }
   ciMethod* target() const
   {
     return function()->target();
@@ -88,6 +72,10 @@
   {
     return ciblock()->has_trap();
   }
+  int trap_index() const
+  {
+    return ciblock()->trap_index();
+  }
   bool is_private_copy() const
   {
     return ciblock()->is_private_copy();
@@ -124,6 +112,14 @@
   {
     return ciblock()->control() == ciBlock::fall_through_bci;
   }
+  int num_exceptions() const
+  {
+    return ciblock()->exceptions()->length();
+  }
+  SharkBlock* exception(int index) const
+  {
+    return function()->block(ciblock()->exceptions()->at(index)->pre_order());
+  }
   int num_successors() const
   {
     return ciblock()->successors()->length();
@@ -132,6 +128,12 @@
   {
     return function()->block(ciblock()->successors()->at(index)->pre_order());
   }
+  int jsr_ret_bci() const
+  {
+    int jsr_level = ciblock()->jsrset()->size();
+    assert(jsr_level > 0, "should be");
+    return ciblock()->jsrset()->record_at(jsr_level - 1)->return_address();
+  }
   SharkBlock* bci_successor(int bci) const;
 
   // Bytecode stream
@@ -151,28 +153,32 @@
 
   // Entry state
  private:
-  int         _num_predecessors;
-  bool        _entered_backwards;
-  SharkState* _entry_state;
+  bool _entered;
+  bool _needs_phis;
 
  public:
-  void add_predecessor(SharkBlock* predecessor)
+  bool entered() const
   {
-    _num_predecessors++;
-    if (predecessor && !_entered_backwards) {
-      if (predecessor->index() >= this->index())
-        _entered_backwards = true;
-    }
-  }
- private:
-  bool never_entered() const
-  {
-    return _num_predecessors == 0;
+    return _entered;
   }
   bool needs_phis() const
   {
-    return _entered_backwards || (_num_predecessors > 1);
+    return _needs_phis;
   }
+
+ private:
+  void enter(SharkBlock* predecessor, bool is_exception);
+
+ public:
+  void enter()
+  {
+    enter(NULL, false);
+  }
+
+ private:
+  SharkState* _entry_state;
+
+ private:
   SharkState* entry_state()
   {
     if (_entry_state == NULL) {
@@ -182,13 +188,25 @@
     return _entry_state;
   }
 
+ private:
+  llvm::BasicBlock* _entry_block;
+
+ public:
+  llvm::BasicBlock* entry_block() const
+  {
+    return _entry_block;
+  }
+
+ public:
+  void initialize();
+
  public:
   void add_incoming(SharkState* incoming_state)
   {
     if (needs_phis()) {
       ((SharkPHIState *) entry_state())->add_incoming(incoming_state);
     }
-    else {
+    else if (_entry_state != incoming_state) {
       assert(_entry_state == NULL, "should be");
       _entry_state = incoming_state;
     }
@@ -197,80 +215,131 @@
   // Current state
  private:
   SharkTrackingState* _current_state;
-  
+
+ private:
+  void set_current_state(SharkTrackingState* current_state)
+  {
+    _current_state = current_state;
+  }
+
  public:
   SharkTrackingState* current_state()
   {
     if (_current_state == NULL)
-      _current_state = new SharkTrackingState(entry_state());
+      set_current_state(new SharkTrackingState(entry_state()));
     return _current_state;
   }
 
+  // Method
  public:
   llvm::Value* method()
   {
     return current_state()->method();
   }
+
+  // Local variables  
  private:
   SharkValue* local(int index)
   {
-    return current_state()->local(index);
+    SharkValue *value = current_state()->local(index);
+    assert(value != NULL, "shouldn't be");
+    assert(value->is_one_word() ||
+           (index + 1 < max_locals() &&
+            current_state()->local(index + 1) == NULL), "should be");
+    return value;
   }
   void set_local(int index, SharkValue* value)
   {
+    assert(value != NULL, "shouldn't be");
     current_state()->set_local(index, value);
+    if (value->is_two_word())
+      current_state()->set_local(index + 1, NULL);
   }
-  void push(SharkValue* value)
+
+  // Expression stack (raw)
+ private:
+  void xpush(SharkValue* value)
   {
     current_state()->push(value);
   }
-  SharkValue* pop()
+  SharkValue* xpop()
   {
     return current_state()->pop();
   }
-  int stack_depth()
+  SharkValue* xstack(int slot)
+  {
+    SharkValue *value = current_state()->stack(slot);
+    assert(value != NULL, "shouldn't be");
+    assert(value->is_one_word() ||
+           (slot > 0 &&
+            current_state()->stack(slot - 1) == NULL), "should be");
+    return value;
+  }
+  int xstack_depth()
   {
     return current_state()->stack_depth();
   }
-  SharkValue* stack(int slot)
-  {
-    return current_state()->stack(slot);
-  }  
 
-  // Handy macros for the various pop, swap and dup bytecodes
+  // Expression stack (cooked)
  private:
-  SharkValue* pop_and_assert_one_word()
+  void push(SharkValue* value)
   {
-    SharkValue* result = pop();
-    assert(result->is_one_word(), "should be");
-    return result;
+    assert(value != NULL, "shouldn't be");
+    xpush(value);
+    if (value->is_two_word())
+      xpush(NULL);
   }
-  SharkValue* pop_and_assert_two_word()
+  SharkValue* pop()
   {
-    SharkValue* result = pop();
-    assert(result->is_two_word(), "should be");
-    return result;
+    int size = current_state()->stack(0) == NULL ? 2 : 1;
+    if (size == 2)
+      xpop();
+    SharkValue *value = xpop();
+    assert(value && value->size() == size, "should be");
+    return value;
   }
 
   // VM calls
  private:
-  llvm::CallInst* call_vm_base(llvm::Constant* callee,
-                               llvm::Value**   args_start,
-                               llvm::Value**   args_end);
+  llvm::CallInst* call_vm_nocheck(llvm::Constant* callee,
+                                  llvm::Value**   args_start,
+                                  llvm::Value**   args_end)
+  {
+    current_state()->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();
+    return res;
+  }
+
+  llvm::CallInst* call_vm(llvm::Constant* callee,
+                          llvm::Value**   args_start,
+                          llvm::Value**   args_end)
+  {
+    llvm::CallInst* res = call_vm_nocheck(callee, args_start, args_end);
+    check_pending_exception();
+    return res;
+  }
 
  public:
+  llvm::CallInst* call_vm(llvm::Constant* callee)
+  {
+    llvm::Value *args[] = {thread()};
+    return call_vm(callee, args, args + 1);
+  }
   llvm::CallInst* call_vm(llvm::Constant* callee,
                           llvm::Value*    arg1)
   {
     llvm::Value *args[] = {thread(), arg1};
-    return call_vm_base(callee, args, args + 2);
+    return call_vm(callee, args, args + 2);
   }
   llvm::CallInst* call_vm(llvm::Constant* callee,
                           llvm::Value*    arg1,
                           llvm::Value*    arg2)
   {
     llvm::Value *args[] = {thread(), arg1, arg2};
-    return call_vm_base(callee, args, args + 3);
+    return call_vm(callee, args, args + 3);
   }
   llvm::CallInst* call_vm(llvm::Constant* callee,
                           llvm::Value*    arg1,
@@ -278,12 +347,40 @@
                           llvm::Value*    arg3)
   {
     llvm::Value *args[] = {thread(), arg1, arg2, arg3};
-    return call_vm_base(callee, args, args + 4);
+    return call_vm(callee, args, args + 4);
   }
 
-  // Code generation
+  llvm::CallInst* call_vm_nocheck(llvm::Constant* callee)
+  {
+    llvm::Value *args[] = {thread()};
+    return call_vm_nocheck(callee, args, args + 1);
+  }
+  llvm::CallInst* call_vm_nocheck(llvm::Constant* callee,
+                                  llvm::Value*    arg1)
+  {
+    llvm::Value *args[] = {thread(), arg1};
+    return call_vm_nocheck(callee, args, args + 2);
+  }
+  llvm::CallInst* call_vm_nocheck(llvm::Constant* callee,
+                                  llvm::Value*    arg1,
+                                  llvm::Value*    arg2)
+  {
+    llvm::Value *args[] = {thread(), arg1, arg2};
+    return call_vm_nocheck(callee, args, args + 3);
+  }
+  llvm::CallInst* call_vm_nocheck(llvm::Constant* callee,
+                                  llvm::Value*    arg1,
+                                  llvm::Value*    arg2,
+                                  llvm::Value*    arg3)
+  {
+    llvm::Value *args[] = {thread(), arg1, arg2, arg3};
+    return call_vm_nocheck(callee, args, args + 4);
+  }
+
+  // Whole-method synchronization
  public:
-  void parse();
+  void acquire_method_lock();  
+  void release_method_lock();  
 
   // Error checking
  private:
@@ -297,12 +394,18 @@
   }
   void check_zero(SharkValue* value);
   void check_bounds(SharkValue* array, SharkValue* index);
-  void check_pending_exception();
-  
+  void check_pending_exception(bool attempt_catch = true);
+  void handle_exception(llvm::Value* exception, bool attempt_catch = true);
+
   // Safepoints
  private:
   void add_safepoint();
 
+  // Returns
+ private:
+  void handle_return(BasicType type, llvm::Value* exception);
+  void release_locked_monitors();
+
   // ldc*
  private:
   void do_ldc();
@@ -356,37 +459,65 @@
   }
   void do_field_access(bool is_get, bool is_field);
 
-  // lcmp
+  // lcmp and [fd]cmp[lg]
  private:
   void do_lcmp();
+  void do_fcmp(bool is_double, bool unordered_is_greater);
 
-  // *return
+  // *return and athrow
  private:
-  void do_return(BasicType basic_type);
+  void do_return(BasicType type)
+  {
+    add_safepoint();
+    handle_return(type, NULL);
+  }
+  void do_athrow()
+  {
+    SharkValue *exception = pop();
+    check_null(exception);
+    handle_exception(exception->jobject_value());
+  }
 
   // if*
  private:
   void do_if(llvm::ICmpInst::Predicate p, SharkValue* b, SharkValue* a);
 
-  // *switch
+  // tableswitch and lookupswitch
  private:
-  void do_tableswitch();
+  int switch_default_dest();
+  int switch_table_length();
+  int switch_key(int i);
+  int switch_dest(int i);
+
+  void do_switch();
 
   // invoke*
  private:
+  llvm::Value* get_basic_callee(llvm::Value* cache);
+  llvm::Value* get_virtual_callee(llvm::Value* cache, SharkValue* receiver);
+  llvm::Value* get_interface_callee(llvm::Value* cache, SharkValue* receiver);
+
+  llvm::Value* get_callee(llvm::Value* cache, SharkValue* receiver);
+
   void do_call();
 
   // checkcast and instanceof
  private:
   void do_instance_check();
 
-  // new and newarray
+  // new and *newarray
  private:
   void do_new();
   void do_newarray();
+  void do_anewarray();
+  void do_multianewarray();
 
   // monitorenter and monitorexit
  private:
   void do_monitorenter();
   void do_monitorexit();
+
+  // The big one
+ public:
+  void parse();
 };

--- a/ports/hotspot/src/share/vm/shark/sharkBuilder.cpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBuilder.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -29,7 +29,7 @@
 using namespace llvm;
 
 SharkBuilder::SharkBuilder()
-  : IRBuilder<>(),
+  : IRBuilder(),
       _module("shark"),
       _module_provider(module()),
       _execution_engine(ExecutionEngine::create(&_module_provider))

--- a/ports/hotspot/src/share/vm/shark/sharkBuilder.hpp	Mon Sep 29 12:04:41 2008 -0400
+++ b/ports/hotspot/src/share/vm/shark/sharkBuilder.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -23,7 +23,7 @@
  *
  */
 
-class SharkBuilder : public llvm::IRBuilder<> {
+class SharkBuilder : public llvm::IRBuilder {
  public:
   SharkBuilder();
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ports/hotspot/src/share/vm/shark/sharkBytecodeTracer.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -0,0 +1,114 @@
+/*
+ * Copyright 1999-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 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/_sharkBytecodeTracer.cpp.incl"
+
+using namespace llvm;
+
+void SharkBytecodeTracer::decode(SharkBuilder*     builder,
+                                 const SharkState* state,
+                                 Value**           tos,
+                                 Value**           tos2)
+{
+  if (state->stack_depth() == 0) {
+    // nothing on the stack
+    *tos = *tos2 = LLVMValue::intptr_constant(EMPTY_SLOT);
+  }
+  else if (state->stack_depth() == 1) {
+    // one item on the stack
+    decode_one_word(builder, state, 0, tos);
+    *tos2 = LLVMValue::intptr_constant(EMPTY_SLOT);
+  }
+  else if (state->stack(0) == NULL) {
+    // two words of a two-word type
+    decode_two_word(builder, state, 0, tos, tos2);
+  }
+  else if (state->stack(1) == NULL) {
+    // a one-word type followed by half of a two-word type
+    decode_one_word(builder, state, 0, tos);
+    decode_two_word(builder, state, 1, tos2, NULL);
+  }
+  else {
+    // two one-word types
+    decode_one_word(builder, state, 0, tos);
+    decode_one_word(builder, state, 1, tos2);
+  }
+}
+
+void SharkBytecodeTracer::decode_one_word(SharkBuilder*     builder,
+                                          const SharkState* state,
+                                          int               index,
+                                          Value**           dst)
+{
+  SharkValue *value = state->stack(index);
+  assert(value && value->is_one_word(), "should be");
+  switch (value->basic_type()) {
+  case T_BOOLEAN:
+  case T_BYTE:
+  case T_CHAR:
+  case T_SHORT:
+  case T_INT:
+#ifdef _LP64
+    *dst = builder->CreateIntCast(
+      value->jint_value(), SharkType::intptr_type(), false);
+#else
+    *dst = value->jint_value();
+#endif // _LP64
+    break;
+
+  case T_FLOAT:
+    *dst = LLVMValue::intptr_constant(UNDECODABLE_SLOT);
+    break;
+
+  case T_OBJECT:
+  case T_ARRAY:
+    *dst = value->intptr_value(builder);
+    break;
+
+  case T_ADDRESS:
+    *dst = LLVMValue::intptr_constant(value->returnAddress_value());
+    break;
+
+  default:
+    tty->print_cr("Unhandled type %s", type2name(value->basic_type()));
+    ShouldNotReachHere();
+  }
+}
+
+void SharkBytecodeTracer::decode_two_word(SharkBuilder*     builder,
+                                          const SharkState* state,
+                                          int               index,
+                                          Value**           dst,
+                                          Value**           dst2)
+{
+  assert(state->stack(index) == NULL, "should be");
+  SharkValue *value = state->stack(index + 1);
+  assert(value && value->is_two_word(), "should be");
+
+  *dst = LLVMValue::intptr_constant(UNDECODABLE_SLOT);
+  if (dst2)
+    *dst2 = LLVMValue::intptr_constant(UNDECODABLE_SLOT);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ports/hotspot/src/share/vm/shark/sharkBytecodeTracer.hpp	Tue Sep 30 08:42:10 2008 -0400
@@ -0,0 +1,49 @@
+/*
+ * Copyright 1999-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 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.
+ *
+ */
+
+class SharkBytecodeTracer : public AllStatic {
+ public:
+  static void decode(SharkBuilder*     builder,
+                     const SharkState* state,
+                     llvm::Value**     tos,
+                     llvm::Value**     tos2);
+ public:
+  static const intptr_t EMPTY_SLOT =
+    NOT_LP64(0x23232323) LP64_ONLY(0x2323232323232323);
+
+  static const intptr_t UNDECODABLE_SLOT =
+    NOT_LP64(0xdeadbabe) LP64_ONLY(0xdeadbabedeadbabe);
+
+ private:
+  static void decode_one_word(SharkBuilder*     builder,
+                              const SharkState* state,
+                              int               index,
+                              llvm::Value**     dst);
+  static void decode_two_word(SharkBuilder*     builder,
+                              const SharkState* state,
+                              int               index,
+                              llvm::Value**     dst,
+                              llvm::Value**     dst2);
+};

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ports/hotspot/src/share/vm/shark/sharkCacheDecache.cpp	Tue Sep 30 08:42:10 2008 -0400
@@ -0,0 +1,225 @@
+/*
+ * Copyright 1999-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 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/_sharkCacheDecache.cpp.incl"
+
+using namespace llvm;
+
+void SharkDecacher::start_frame()
+{
+  // Start recording the debug information
+  _pc_offset = function()->code_offset();
+  _oopmap = new OopMap(
+    oopmap_slot_munge(function()->oopmap_frame_size()),
+    oopmap_slot_munge(function()->arg_size()));
+  debug_info()->add_safepoint(pc_offset(), oopmap());
+}
+
+void SharkDecacher::start_stack(int num_slots, int max_slots)
+{
+  // Create the array we'll record our stack slots in
+  _exparray = new GrowableArray<ScopeValue*>(num_slots);
+
+  // Trim back the stack if necessary
+  if (num_slots != max_slots) {
+    function()->CreateStoreZeroStackPointer(
+      builder()->CreatePtrToInt(
+        function()->CreateAddressOfFrameEntry(
+          function()->stack_slots_offset() + max_slots - num_slots),
+        SharkType::intptr_type()));
+  }
+}
+
+void SharkDecacher::process_stack_slot(int          index,
+                                       SharkValue** addr,
+                                       int          offset)
+{
+  SharkValue *value = *addr;
+
+  // Write the value to the frame if necessary
+  if (stack_slot_needs_write(index, value)) {
+    builder()->CreateStore(
+      value->generic_value(),
+      function()->CreateAddressOfFrameEntry(
+        adjusted_offset(value, offset),
+        SharkType::to_stackType(value->basic_type())));
+  }
+
+  // Record the value in the oopmap if necessary
+  if (stack_slot_needs_oopmap(index, value)) {
+    oopmap()->set_oop(slot2reg(offset));
+  }
+
+  // Record the value in the debuginfo if necessary
+  if (stack_slot_needs_debuginfo(index, value)) {
+    exparray()->append(slot2lv(offset, stack_location_type(index, addr)));
+  }
+}
+
+void SharkDecacher::start_monitors(int num_monitors)
+{
+  // Create the array we'll record our monitors in
+  _monarray = new GrowableArray<MonitorValue*>(num_monitors);
+}
+
+void SharkDecacher::process_monitor(int index, int box_offset)
+{
+  int obj_offset =
+    box_offset + (BasicObjectLock::obj_offset_in_bytes() >> LogBytesPerWord);
+
+  oopmap()->set_oop(slot2reg(obj_offset));
+
+  monarray()->append(new MonitorValue(
+    slot2lv (obj_offset, Location::oop),
+    slot2loc(box_offset, Location::normal)));
+}
+
+void SharkDecacher::process_exception_slot(int offset)
+{
+  // Record the exception slot
+  oopmap()->set_oop(slot2reg(offset));
+}
+
+void SharkDecacher::process_method_slot(llvm::Value** value, int offset)
+{
+  // Decache the method pointer
+  builder()->CreateStore(
+    *value,
+    function()->CreateAddressOfFrameEntry(
+      offset,
+      SharkType::methodOop_type()));
+  oopmap()->set_oop(slot2reg(offset));  
+}
+
+void SharkDecacher::process_pc_slot(int offset)
+{
+  // Record the PC
+  builder()->CreateStore(
+    builder()->CreateAdd(
+      function()->base_pc(), LLVMValue::intptr_constant(pc_offset())),
+    function()->CreateAddressOfFrameEntry(offset));
+}
+  
+void SharkDecacher::start_locals(int num_locals)
+{
+  // Create the array we'll record our local variables in
+  _locarray = new GrowableArray<ScopeValue*>(num_locals);}
+
+void SharkDecacher::process_local_slot(int          index,
+                                       SharkValue** addr,
+                                       int          offset)
+{
+  SharkValue *value = *addr;
+
+  // Write the value to the frame if necessary
+  if (local_slot_needs_write(index, value)) {
+    builder()->CreateStore(
+      value->generic_value(),
+      function()->CreateAddressOfFrameEntry(
+        adjusted_offset(value, offset),
+        SharkType::to_stackType(value->basic_type())));
+  }
+
+  // Record the value in the oopmap if necessary
+  if (local_slot_needs_oopmap(index, value)) {
+    oopmap()->set_oop(slot2reg(offset));
+  }
+
+  // Record the value in the debuginfo if necessary
+  if (local_slot_needs_debuginfo(index, value)) {
+    locarray()->append(slot2lv(offset, local_location_type(index, addr)));
+  }
+}
+
+void SharkDecacher::end_frame()
+{
+  // Record the scope
+  debug_info()->describe_scope(
+    pc_offset(),
+    function()->target(),
+    bci(),
+    debug_info()->create_scope_values(locarray()),
+    debug_info()->create_scope_values(exparray()),
+    debug_info()->create_monitor_values(monarray()));
+
+  // Finish recording the debug information
+  debug_info()->end_safepoint(pc_offset());
+}
+
+void SharkCacher::start_stack(int num_slots, int max_slots)
+{
+  // Restore the stack if necessary
+  if (num_slots != max_slots) {
+    function()->CreateStoreZeroStackPointer(
+      builder()->CreatePtrToInt(
+        function()->CreateAddressOfFrameEntry(
+          function()->stack_slots_offset()),
+        SharkType::intptr_type()));
+  }
+}
+
+void SharkCacher::process_stack_slot(int          index,
+                                     SharkValue** addr,
+                                     int          offset)
+{
+  SharkValue *value = *addr;
+
+  // Read the value from the frame if necessary
+  if (stack_slot_needs_read(index, value)) {
+    *addr = SharkValue::create_generic(
+      value->type(),
+      builder()->CreateLoad(
+        function()->CreateAddressOfFrameEntry(
+          adjusted_offset(value, offset),
+          SharkType::to_stackType(value->basic_type()))));
+  }
+}
+
+void SharkCacher::process_method_slot(llvm::Value** value, int offset)
+{
+  // Cache the method pointer
+  *value = builder()->CreateLoad(
+    function()->CreateAddressOfFrameEntry(
+      offset,
+      SharkType::methodOop_type()));
+}
+
+void SharkCacher::process_local_slot(int          index,
+                                     SharkValue** addr,
+                                     int          offset)
+{
+  SharkValue *value = *addr;
+
+  // Read the value from the frame if necessary
+  if (local_slot_needs_read(index, value)) {
+    *addr = SharkValue::create_generic(
+      value->type(),
+      builder()->CreateLoad(
+        function()->CreateAddressOfFrameEntry(
+          adjusted_offset(value, offset),
+          SharkType::to_stackType(value->basic_type()))));
+  }
+}