jdk8-mips64-public/hotspot: comparison src/share/vm/runtime/vframe.hpp

-:36d1d483d5d6
+:da91efe96a93
 /*
-* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
 * 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.
 class javaVFrame: public vframe {
 public:
 // JVM state
-virtual methodOop                    method()         const = 0;
+virtual Method*                      method()         const = 0;
 virtual int                          bci()            const = 0;
 virtual StackValueCollection*        locals()         const = 0;
 virtual StackValueCollection*        expressions()    const = 0;
 // the order returned by monitors() is from oldest -> youngest#4418568
 virtual GrowableArray<MonitorInfo*>* monitors()       const = 0;
 };
 class interpretedVFrame: public javaVFrame {
 public:
 // JVM state
-methodOop                    method()         const;
+Method*                      method()         const;
 int                          bci()            const;
 StackValueCollection*        locals()         const;
 StackValueCollection*        expressions()    const;
 GrowableArray<MonitorInfo*>* monitors()       const;
 // 2) the monitor lock
 class MonitorInfo : public ResourceObj {
 private:
 oop        _owner; // the object owning the monitor
 BasicLock* _lock;
-oop        _owner_klass; // klass if owner was scalar replaced
+oop        _owner_klass; // klass (mirror) if owner was scalar replaced
 bool       _eliminated;
 bool       _owner_is_scalar_replaced;
 public:
 // Constructor
 MonitorInfo(oop owner, BasicLock* lock, bool eliminated, bool owner_is_scalar_replaced) {
 // Accessors
 oop        owner() const {
 assert(!_owner_is_scalar_replaced, "should not be called for scalar replaced object");
 return _owner;
 }
-klassOop   owner_klass() const {
+oop   owner_klass() const {
 assert(_owner_is_scalar_replaced, "should not be called for not scalar replaced object");
-return (klassOop)_owner_klass;
+return _owner_klass;
 }
 BasicLock* lock()  const { return _lock;  }
 bool eliminated()  const { return _eliminated; }
 bool owner_is_scalar_replaced()  const { return _owner_is_scalar_replaced; }
 };
 enum { interpreted_mode, compiled_mode, at_end_mode } _mode;
 int _sender_decode_offset;
 // Cached information
-methodOop _method;
+Method* _method;
 int       _bci;
 // Should VM activations be ignored or not
 bool _stop_at_java_call_stub;
 vframeStreamCommon(JavaThread* thread) : _reg_map(thread, false) {
 _thread = thread;
 }
 // Accessors
-methodOop method() const { return _method; }
+Method* method() const { return _method; }
 int bci() const { return _bci; }
 intptr_t* frame_id() const { return _frame.id(); }
 address frame_pc() const { return _frame.pc(); }
 CodeBlob*          cb()         const { return _frame.cb();  }
 }
 // Decode first part of scopeDesc
 DebugInfoReadStream buffer(nm(), decode_offset);
 _sender_decode_offset = buffer.read_int();
-_method               = methodOop(buffer.read_oop());
+_method               = buffer.read_method();
 _bci                  = buffer.read_bci();
 assert(_method->is_method(), "checking type of decoded method");
 }
 return false;
 }
 inline void vframeStreamCommon::fill_from_interpreter_frame() {
-methodOop method = _frame.interpreter_frame_method();
+Method* method = _frame.interpreter_frame_method();
 intptr_t  bcx    = _frame.interpreter_frame_bcx();
 int       bci    = method->validate_bci_from_bcx(bcx);
 // 6379830 AsyncGetCallTrace sometimes feeds us wild frames.
 if (bci < 0) {
 found_bad_method_frame();

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/runtime/vframe.hpp

src/share/vm/runtime/vframe.hpp