1 /*
   2  * Copyright (c) 1999, 2015, 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_JVMCI_JVMCIENV_HPP
  26 #define SHARE_VM_JVMCI_JVMCIENV_HPP
  27 
  28 #include "classfile/systemDictionary.hpp"
  29 #include "code/debugInfoRec.hpp"
  30 #include "code/dependencies.hpp"
  31 #include "code/exceptionHandlerTable.hpp"
  32 #include "compiler/oopMap.hpp"
  33 #include "runtime/thread.hpp"
  34 
  35 class CompileTask;
  36 
  37 // Bring the JVMCI compiler thread into the VM state.
  38 #define JVMCI_VM_ENTRY_MARK                       \
  39   JavaThread* thread = JavaThread::current(); \
  40   ThreadInVMfromNative __tiv(thread);       \
  41   ResetNoHandleMark rnhm;                   \
  42   HandleMarkCleaner __hm(thread);           \
  43   Thread* THREAD = thread;                  \
  44   debug_only(VMNativeEntryWrapper __vew;)
  45 
  46 #define JVMCI_EXCEPTION_CONTEXT \
  47   JavaThread* thread=JavaThread::current(); \
  48   Thread* THREAD = thread;
  49 
  50 //
  51 // This class is the top level broker for requests from the compiler
  52 // to the VM.
  53 class JVMCIEnv : StackObj {
  54   CI_PACKAGE_ACCESS_TO
  55 
  56   friend class JVMCIVMStructs;
  57   friend class CompileBroker;
  58   friend class Dependencies;  // for get_object, during logging
  59 
  60 public:
  61 
  62   enum CodeInstallResult {
  63      ok,
  64      dependencies_failed,
  65      dependencies_invalid,
  66      cache_full,
  67      code_too_large
  68   };
  69 
  70   // Look up a klass by name from a particular class loader (the accessor's).
  71   // If require_local, result must be defined in that class loader, or NULL.
  72   // If !require_local, a result from remote class loader may be reported,
  73   // if sufficient class loader constraints exist such that initiating
  74   // a class loading request from the given loader is bound to return
  75   // the class defined in the remote loader (or throw an error).
  76   //
  77   // Return an unloaded klass if !require_local and no class at all is found.
  78   //
  79   // The CI treats a klass as loaded if it is consistently defined in
  80   // another loader, even if it hasn't yet been loaded in all loaders
  81   // that could potentially see it via delegation.
  82   static KlassHandle get_klass_by_name(KlassHandle accessing_klass,
  83                              Symbol* klass_name,
  84                              bool require_local);
  85 
  86   // Constant pool access.
  87   static KlassHandle   get_klass_by_index(const constantPoolHandle& cpool,
  88                                 int klass_index,
  89                                 bool& is_accessible,
  90                                 KlassHandle loading_klass);
  91   static void   get_field_by_index(instanceKlassHandle loading_klass, fieldDescriptor& fd,
  92                                 int field_index);
  93   static methodHandle  get_method_by_index(const constantPoolHandle& cpool,
  94                                  int method_index, Bytecodes::Code bc,
  95                                  instanceKlassHandle loading_klass);
  96 
  97   JVMCIEnv(CompileTask* task, int system_dictionary_modification_counter);
  98 
  99 private:
 100   CompileTask*     _task;
 101   int              _system_dictionary_modification_counter;
 102 
 103   // Compilation result values
 104   const char*      _failure_reason;
 105   bool             _retryable;
 106 
 107   // Cache JVMTI state
 108   bool  _jvmti_can_hotswap_or_post_breakpoint;
 109   bool  _jvmti_can_access_local_variables;
 110   bool  _jvmti_can_post_on_exceptions;
 111 
 112   // Implementation methods for loading and constant pool access.
 113   static KlassHandle get_klass_by_name_impl(KlassHandle& accessing_klass,
 114                                   const constantPoolHandle& cpool,
 115                                   Symbol* klass_name,
 116                                   bool require_local);
 117   static KlassHandle   get_klass_by_index_impl(const constantPoolHandle& cpool,
 118                                      int klass_index,
 119                                      bool& is_accessible,
 120                                      KlassHandle loading_klass);
 121   static void   get_field_by_index_impl(instanceKlassHandle loading_klass, fieldDescriptor& fd,
 122                                      int field_index);
 123   static methodHandle  get_method_by_index_impl(const constantPoolHandle& cpool,
 124                                       int method_index, Bytecodes::Code bc,
 125                                       instanceKlassHandle loading_klass);
 126 
 127   // Helper methods
 128   static bool       check_klass_accessibility(KlassHandle accessing_klass, KlassHandle resolved_klass);
 129   static methodHandle  lookup_method(instanceKlassHandle  accessor,
 130                            instanceKlassHandle  holder,
 131                            Symbol*         name,
 132                            Symbol*         sig,
 133                            Bytecodes::Code bc);
 134 
 135   private:
 136 
 137   // Is this thread currently in the VM state?
 138   static bool is_in_vm();
 139 
 140   // Helper routine for determining the validity of a compilation
 141   // with respect to concurrent class loading.
 142   static JVMCIEnv::CodeInstallResult check_for_system_dictionary_modification(Dependencies* target, Handle compiled_code,
 143                                                                               JVMCIEnv* env, char** failure_detail);
 144 
 145 public:
 146   CompileTask* task() { return _task; }
 147 
 148   const char* failure_reason() { return _failure_reason; }
 149   bool retryable() { return _retryable; }
 150 
 151   void set_failure(const char* reason, bool retryable) {
 152     _failure_reason = reason;
 153     _retryable = retryable;
 154   }
 155 
 156   // Register the result of a compilation.
 157   static JVMCIEnv::CodeInstallResult register_method(
 158                        const methodHandle&       target,
 159                        nmethod*&                 nm,
 160                        int                       entry_bci,
 161                        CodeOffsets*              offsets,
 162                        int                       orig_pc_offset,
 163                        CodeBuffer*               code_buffer,
 164                        int                       frame_words,
 165                        OopMapSet*                oop_map_set,
 166                        ExceptionHandlerTable*    handler_table,
 167                        AbstractCompiler*         compiler,
 168                        DebugInformationRecorder* debug_info,
 169                        Dependencies*             dependencies,
 170                        JVMCIEnv*                 env,
 171                        int                       compile_id,
 172                        bool                      has_unsafe_access,
 173                        bool                      has_wide_vector,
 174                        Handle                    installed_code,
 175                        Handle                    compiled_code,
 176                        Handle                    speculation_log);
 177 
 178   // converts the Klass* representing the holder of a method into a
 179   // InstanceKlass*.  This is needed since the holder of a method in
 180   // the bytecodes could be an array type.  Basically this converts
 181   // array types into java/lang/Object and other types stay as they are.
 182   static instanceKlassHandle get_instance_klass_for_declared_method_holder(KlassHandle klass);
 183 };
 184 
 185 #endif // SHARE_VM_JVMCI_JVMCIENV_HPP