*** old/src/share/vm/prims/methodHandleWalk.hpp	Tue Aug 30 18:43:13 2011
--- new/src/share/vm/prims/methodHandleWalk.hpp	Tue Aug 30 18:43:13 2011

*** 72,81 ****
--- 72,82 ----
    void next(TRAPS) {
      assert(!is_last(), "");
      set_method_handle(MethodHandle_vmtarget_oop(), THREAD);
    }
  
+   Handle root()                 { return _root; }
    Handle method_handle()        { return _method_handle; }
    oop    method_handle_oop()    { return _method_handle(); }
    oop    method_type_oop()      { return MethodHandle_type_oop(); }
    oop    vmtarget_oop()         { return MethodHandle_vmtarget_oop(); }
  

*** 108,118 ****
--- 109,118 ----
  #ifdef ASSERT
    // Print a symbolic description of a method handle chain, including
    // the signature for each method.  The signatures are printed in
    // slot order to make it easier to understand.
    void print();
    static void print(Handle mh);
    static void print(oopDesc* mh);
  #endif
  };
  
  

*** 275,284 ****
--- 275,288 ----
    KlassHandle  _rklass;        // Return type for casting.
    BasicType    _rtype;
    KlassHandle  _target_klass;
    Thread*      _thread;
  
+   int          _selectAlternative_bci; // These are used for capturing profiles from GWTs
+   int          _taken_count;
+   int          _not_taken_count;
+ 
    // Values used by the compiler.
    static jvalue zero_jvalue;
    static jvalue one_jvalue;
  
    // Fake constant pool entry.

*** 370,379 ****
--- 374,384 ----
      assert(_cur_stack >= 0, "sanity");
    }
  
    unsigned char* bytecode()        const { return _bytecode.adr_at(0); }
    int            bytecode_length() const { return _bytecode.length(); }
+   int            cur_bci()         const { return _bytecode.length(); }
  
    // Fake constant pool.
    int cpool_oop_put(int tag, Handle con) {
      if (con.is_null())  return 0;
      ConstantValue* cv = new ConstantValue(tag, con);

*** 434,443 ****
--- 439,450 ----
    int cpool_name_and_type_put(int name_index, int signature_index) {
      return cpool_oop_reference_put(JVM_CONSTANT_NameAndType, name_index, signature_index, methodHandle());
    }
  
    void emit_bc(Bytecodes::Code op, int index = 0, int args_size = -1);
+   void update_branch_dest(int src, int dst);
+   void emit_load(ArgToken arg);
    void emit_load(BasicType bt, int index);
    void emit_store(BasicType bt, int index);
    void emit_load_constant(ArgToken arg);
  
    virtual ArgToken make_parameter(BasicType type, klassOop tk, int argnum, TRAPS) {

*** 453,467 ****
--- 460,477 ----
  
    virtual ArgToken make_conversion(BasicType type, klassOop tk, Bytecodes::Code op, const ArgToken& src, TRAPS);
    virtual ArgToken make_fetch(BasicType type, klassOop tk, Bytecodes::Code op, const ArgToken& base, const ArgToken& offset, TRAPS);
    virtual ArgToken make_invoke(methodHandle m, vmIntrinsics::ID iid, Bytecodes::Code op, bool tailcall, int argc, ArgToken* argv, TRAPS);
  
+   // Check for profiling information on a GWT and return true if it's found
+   bool fetch_counts(ArgToken a1, ArgToken a2);
+ 
    // Get a real constant pool.
    constantPoolHandle get_constant_pool(TRAPS) const;
  
    // Get a real methodOop.
-   methodHandle get_method_oop(TRAPS) const;
  
  public:
    MethodHandleCompiler(Handle root, Symbol* name, Symbol* signature, int invoke_count, bool for_invokedynamic, TRAPS);
  
    // Compile the given MH chain into bytecode.