1 /*
   2  * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_RUNTIME_VFRAME_HP_HPP
  26 #define SHARE_VM_RUNTIME_VFRAME_HP_HPP
  27 
  28 #include "runtime/vframe.hpp"
  29 
  30 class compiledVFrame: public javaVFrame {
  31  public:
  32   // JVM state
  33   Method*                      method()             const;
  34   int                          bci()                const;
  35   bool                         should_reexecute()   const;
  36   StackValueCollection*        locals()             const;
  37   StackValueCollection*        expressions()        const;
  38   GrowableArray<MonitorInfo*>* monitors()           const;
  39   int                          vframe_id()          const { return _vframe_id; }
  40 
  41   void set_locals(StackValueCollection* values) const;
  42 
  43   // Virtuals defined in vframe
  44   bool is_compiled_frame() const { return true; }
  45   vframe* sender() const;
  46   bool is_top() const;
  47 
  48   // Casting
  49   static compiledVFrame* cast(vframe* vf) {
  50     assert(vf == NULL || vf->is_compiled_frame(), "must be compiled frame");
  51     return (compiledVFrame*) vf;
  52   }
  53 
  54  public:
  55   // Constructors
  56   compiledVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread, CompiledMethod* nm);
  57 
  58   // Update a local in a compiled frame. Update happens when deopt occurs
  59   void update_local(BasicType type, int index, jvalue value);
  60 
  61   // Returns the active nmethod
  62   CompiledMethod*  code() const;
  63 
  64   // Returns the scopeDesc
  65   ScopeDesc* scope() const { return _scope; }
  66 
  67   // Returns SynchronizationEntryBCI or bci() (used for synchronization)
  68   int raw_bci() const;
  69 
  70  protected:
  71   ScopeDesc* _scope;
  72   int _vframe_id;
  73 
  74   //StackValue resolve(ScopeValue* sv) const;
  75   BasicLock* resolve_monitor_lock(Location location) const;
  76   StackValue *create_stack_value(ScopeValue *sv) const;
  77 
  78  private:
  79   compiledVFrame(const frame* fr, const RegisterMap* reg_map, JavaThread* thread, ScopeDesc* scope, int vframe_id);
  80 
  81 #ifndef PRODUCT
  82  public:
  83   void verify() const;
  84 #endif
  85 };
  86 
  87 // In order to implement set_locals for compiled vframes we must
  88 // store updated locals in a data structure that contains enough
  89 // information to recognize equality with a vframe and to store
  90 // any updated locals.
  91 
  92 class jvmtiDeferredLocalVariable;
  93 class jvmtiDeferredLocalVariableSet : public CHeapObj<mtCompiler> {
  94 private:
  95 
  96   Method* _method;
  97   int       _bci;
  98   intptr_t* _id;
  99   int _vframe_id;
 100   GrowableArray<jvmtiDeferredLocalVariable*>* _locals;
 101 
 102  public:
 103   // JVM state
 104   Method*                           method()         const  { return _method; }
 105   int                               bci()            const  { return _bci; }
 106   intptr_t*                         id()             const  { return _id; }
 107   int                               vframe_id()      const  { return _vframe_id; }
 108   GrowableArray<jvmtiDeferredLocalVariable*>* locals()         const  { return _locals; }
 109   void                              set_local_at(int idx, BasicType typ, jvalue val);
 110 
 111   // Does the vframe match this jvmtiDeferredLocalVariableSet
 112   bool                              matches(vframe* vf);
 113   // GC
 114   void                              oops_do(OopClosure* f);
 115 
 116   // constructor
 117   jvmtiDeferredLocalVariableSet(Method* method, int bci, intptr_t* id, int vframe_id);
 118 
 119   // destructor
 120   ~jvmtiDeferredLocalVariableSet();
 121 
 122 
 123 };
 124 
 125 class jvmtiDeferredLocalVariable : public CHeapObj<mtCompiler> {
 126   public:
 127 
 128     jvmtiDeferredLocalVariable(int index, BasicType type, jvalue value);
 129 
 130     BasicType type(void)                   { return _type; }
 131     int index(void)                        { return _index; }
 132     jvalue value(void)                     { return _value; }
 133     // Only mutator is for value as only it can change
 134     void set_value(jvalue value)           { _value = value; }
 135     // For gc
 136     oop* oop_addr(void)                    { return (oop*) &_value.l; }
 137 
 138   private:
 139 
 140     BasicType         _type;
 141     jvalue            _value;
 142     int               _index;
 143 
 144 };
 145 
 146 #endif // SHARE_VM_RUNTIME_VFRAME_HP_HPP