1 /*

     2  * Copyright (c) 1999, 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_CI_CIENV_HPP

    26 #define SHARE_VM_CI_CIENV_HPP

    27 

    28 #include "ci/ciClassList.hpp"

    29 #include "ci/ciObjectFactory.hpp"

    30 #include "classfile/systemDictionary.hpp"

    31 #include "code/debugInfoRec.hpp"

    32 #include "code/dependencies.hpp"

    33 #include "code/exceptionHandlerTable.hpp"

    34 #include "compiler/oopMap.hpp"

    35 #include "runtime/thread.hpp"

    36 

    37 class CompileTask;

    38 

    39 // ciEnv

    40 //

    41 // This class is the top level broker for requests from the compiler

    42 // to the VM.

    43 class ciEnv : StackObj {

    44   CI_PACKAGE_ACCESS_TO

    45 

    46   friend class CompileBroker;

    47   friend class Dependencies;  // for get_object, during logging

    48 

    49 private:

    50   Arena*           _arena;       // Alias for _ciEnv_arena except in init_shared_objects()

    51   Arena            _ciEnv_arena;

    52   int              _system_dictionary_modification_counter;

    53   ciObjectFactory* _factory;

    54   OopRecorder*     _oop_recorder;

    55   DebugInformationRecorder* _debug_info;

    56   Dependencies*    _dependencies;

    57   const char*      _failure_reason;

    58   bool             _inc_decompile_count_on_failure;

    59   int              _compilable;

    60   bool             _break_at_compile;

    61   int              _num_inlined_bytecodes;

    62   CompileTask*     _task;           // faster access to CompilerThread::task

    63   CompileLog*      _log;            // faster access to CompilerThread::log

    64   void*            _compiler_data;  // compiler-specific stuff, if any

    65 

    66   char* _name_buffer;

    67   int   _name_buffer_len;

    68 

    69   // Cache Jvmti state

    70   bool  _jvmti_can_hotswap_or_post_breakpoint;

    71   bool  _jvmti_can_access_local_variables;

    72   bool  _jvmti_can_post_on_exceptions;

    73   bool  _jvmti_can_pop_frame;

    74 

    75   // Cache DTrace flags

    76   bool  _dtrace_extended_probes;

    77   bool  _dtrace_monitor_probes;

    78   bool  _dtrace_method_probes;

    79   bool  _dtrace_alloc_probes;

    80 

    81   // Distinguished instances of certain ciObjects..

    82   static ciObject*              _null_object_instance;

    83 

    84 #define WK_KLASS_DECL(name, ignore_s, ignore_o) static ciInstanceKlass* _##name;

    85   WK_KLASSES_DO(WK_KLASS_DECL)

    86 #undef WK_KLASS_DECL

    87 

    88   static ciSymbol*        _unloaded_cisymbol;

    89   static ciInstanceKlass* _unloaded_ciinstance_klass;

    90   static ciObjArrayKlass* _unloaded_ciobjarrayklass;

    91 

    92   static jobject _ArrayIndexOutOfBoundsException_handle;

    93   static jobject _ArrayStoreException_handle;

    94   static jobject _ClassCastException_handle;

    95 

    96   ciInstance* _NullPointerException_instance;

    97   ciInstance* _ArithmeticException_instance;

    98   ciInstance* _ArrayIndexOutOfBoundsException_instance;

    99   ciInstance* _ArrayStoreException_instance;

   100   ciInstance* _ClassCastException_instance;

   101 

   102   ciInstance* _the_null_string;      // The Java string "null"

   103   ciInstance* _the_min_jint_string; // The Java string "-2147483648"

   104 

   105   // Look up a klass by name from a particular class loader (the accessor's).

   106   // If require_local, result must be defined in that class loader, or NULL.

   107   // If !require_local, a result from remote class loader may be reported,

   108   // if sufficient class loader constraints exist such that initiating

   109   // a class loading request from the given loader is bound to return

   110   // the class defined in the remote loader (or throw an error).

   111   //

   112   // Return an unloaded klass if !require_local and no class at all is found.

   113   //

   114   // The CI treats a klass as loaded if it is consistently defined in

   115   // another loader, even if it hasn't yet been loaded in all loaders

   116   // that could potentially see it via delegation.

   117   ciKlass* get_klass_by_name(ciKlass* accessing_klass,

   118                              ciSymbol* klass_name,

   119                              bool require_local);

   120 

   121   // Constant pool access.

   122   ciKlass*   get_klass_by_index(const constantPoolHandle& cpool,

   123                                 int klass_index,

   124                                 bool& is_accessible,

   125                                 ciInstanceKlass* loading_klass);

   126   ciConstant get_constant_by_index(const constantPoolHandle& cpool,

   127                                    int pool_index, int cache_index,

   128                                    ciInstanceKlass* accessor);

   129   ciField*   get_field_by_index(ciInstanceKlass* loading_klass,

   130                                 int field_index);

   131   ciMethod*  get_method_by_index(const constantPoolHandle& cpool,

   132                                  int method_index, Bytecodes::Code bc,

   133                                  ciInstanceKlass* loading_klass);

   134 

   135   // Implementation methods for loading and constant pool access.

   136   ciKlass* get_klass_by_name_impl(ciKlass* accessing_klass,

   137                                   const constantPoolHandle& cpool,

   138                                   ciSymbol* klass_name,

   139                                   bool require_local);

   140   ciKlass*   get_klass_by_index_impl(const constantPoolHandle& cpool,

   141                                      int klass_index,

   142                                      bool& is_accessible,

   143                                      ciInstanceKlass* loading_klass);

   144   ciConstant get_constant_by_index_impl(const constantPoolHandle& cpool,

   145                                         int pool_index, int cache_index,

   146                                         ciInstanceKlass* loading_klass);

   147   ciField*   get_field_by_index_impl(ciInstanceKlass* loading_klass,

   148                                      int field_index);

   149   ciMethod*  get_method_by_index_impl(const constantPoolHandle& cpool,

   150                                       int method_index, Bytecodes::Code bc,

   151                                       ciInstanceKlass* loading_klass);

   152 

   153   // Helper methods

   154   bool       check_klass_accessibility(ciKlass* accessing_klass,

   155                                       Klass* resolved_klass);

   156   Method*    lookup_method(ciInstanceKlass* accessor,

   157                            ciKlass*         holder,

   158                            Symbol*          name,

   159                            Symbol*          sig,

   160                            Bytecodes::Code  bc,

   161                            constantTag      tag);

   162 

   163   // Get a ciObject from the object factory.  Ensures uniqueness

   164   // of ciObjects.

   165   ciObject* get_object(oop o) {

   166     if (o == NULL) {

   167       return _null_object_instance;

   168     } else {

   169       return _factory->get(o);

   170     }

   171   }

   172 

   173   ciSymbol* get_symbol(Symbol* o) {

   174     if (o == NULL) {

   175       ShouldNotReachHere();

   176       return NULL;

   177     } else {

   178       return _factory->get_symbol(o);

   179     }

   180   }

   181 

   182   ciMetadata* get_metadata(Metadata* o) {

   183     if (o == NULL) {

   184       return NULL;

   185     } else {

   186       return _factory->get_metadata(o);

   187     }

   188   }

   189 

   190   void ensure_metadata_alive(ciMetadata* m) {

   191     _factory->ensure_metadata_alive(m);

   192   }

   193 

   194   ciInstance* get_instance(oop o) {

   195     if (o == NULL) return NULL;

   196     return get_object(o)->as_instance();

   197   }

   198   ciObjArrayKlass* get_obj_array_klass(Klass* o) {

   199     if (o == NULL) return NULL;

   200     return get_metadata(o)->as_obj_array_klass();

   201   }

   202   ciTypeArrayKlass* get_type_array_klass(Klass* o) {

   203     if (o == NULL) return NULL;

   204     return get_metadata(o)->as_type_array_klass();

   205   }

   206   ciKlass* get_klass(Klass* o) {

   207     if (o == NULL) return NULL;

   208     return get_metadata(o)->as_klass();

   209   }

   210   ciInstanceKlass* get_instance_klass(Klass* o) {

   211     if (o == NULL) return NULL;

   212     return get_metadata(o)->as_instance_klass();

   213   }

   214   ciMethod* get_method(Method* o) {

   215     if (o == NULL) return NULL;

   216     return get_metadata(o)->as_method();

   217   }

   218   ciMethodData* get_method_data(MethodData* o) {

   219     if (o == NULL) return NULL;

   220     return get_metadata(o)->as_method_data();

   221   }

   222 

   223   ciMethod* get_method_from_handle(Method* method);

   224 

   225   ciInstance* get_or_create_exception(jobject& handle, Symbol* name);

   226 

   227   // Get a ciMethod representing either an unfound method or

   228   // a method with an unloaded holder.  Ensures uniqueness of

   229   // the result.

   230   ciMethod* get_unloaded_method(ciKlass*         holder,

   231                                 ciSymbol*        name,

   232                                 ciSymbol*        signature,

   233                                 ciInstanceKlass* accessor) {

   234     ciInstanceKlass* declared_holder = get_instance_klass_for_declared_method_holder(holder);

   235     return _factory->get_unloaded_method(declared_holder, name, signature, accessor);

   236   }

   237 

   238   // Get a ciKlass representing an unloaded klass.

   239   // Ensures uniqueness of the result.

   240   ciKlass* get_unloaded_klass(ciKlass*  accessing_klass,

   241                               ciSymbol* name) {

   242     return _factory->get_unloaded_klass(accessing_klass, name, true);

   243   }

   244 

   245   // Get a ciKlass representing an unloaded klass mirror.

   246   // Result is not necessarily unique, but will be unloaded.

   247   ciInstance* get_unloaded_klass_mirror(ciKlass* type) {

   248     return _factory->get_unloaded_klass_mirror(type);

   249   }

   250 

   251   // Get a ciInstance representing an unresolved method handle constant.

   252   ciInstance* get_unloaded_method_handle_constant(ciKlass*  holder,

   253                                                   ciSymbol* name,

   254                                                   ciSymbol* signature,

   255                                                   int       ref_kind) {

   256     return _factory->get_unloaded_method_handle_constant(holder, name, signature, ref_kind);

   257   }

   258 

   259   // Get a ciInstance representing an unresolved method type constant.

   260   ciInstance* get_unloaded_method_type_constant(ciSymbol* signature) {

   261     return _factory->get_unloaded_method_type_constant(signature);

   262   }

   263 

   264   // See if we already have an unloaded klass for the given name

   265   // or return NULL if not.

   266   ciKlass *check_get_unloaded_klass(ciKlass*  accessing_klass, ciSymbol* name) {

   267     return _factory->get_unloaded_klass(accessing_klass, name, false);

   268   }

   269 

   270   // Get a ciReturnAddress corresponding to the given bci.

   271   // Ensures uniqueness of the result.

   272   ciReturnAddress* get_return_address(int bci) {

   273     return _factory->get_return_address(bci);

   274   }

   275 

   276   // Get a ciMethodData representing the methodData for a method

   277   // with none.

   278   ciMethodData* get_empty_methodData() {

   279     return _factory->get_empty_methodData();

   280   }

   281 

   282   // General utility : get a buffer of some required length.

   283   // Used in symbol creation.

   284   char* name_buffer(int req_len);

   285 

   286   // Is this thread currently in the VM state?

   287   static bool is_in_vm();

   288 

   289   // Helper routine for determining the validity of a compilation with

   290   // respect to method dependencies (e.g. concurrent class loading).

   291   void validate_compile_task_dependencies(ciMethod* target);

   292 

   293 public:

   294   enum {

   295     MethodCompilable,

   296     MethodCompilable_not_at_tier,

   297     MethodCompilable_never

   298   };

   299 

   300   ciEnv(CompileTask* task, int system_dictionary_modification_counter);

   301   // Used only during initialization of the ci

   302   ciEnv(Arena* arena);

   303   ~ciEnv();

   304 

   305   OopRecorder* oop_recorder() { return _oop_recorder; }

   306   void set_oop_recorder(OopRecorder* r) { _oop_recorder = r; }

   307 

   308   DebugInformationRecorder* debug_info() { return _debug_info; }

   309   void set_debug_info(DebugInformationRecorder* i) { _debug_info = i; }

   310 

   311   Dependencies* dependencies() { return _dependencies; }

   312   void set_dependencies(Dependencies* d) { _dependencies = d; }

   313 

   314   // This is true if the compilation is not going to produce code.

   315   // (It is reasonable to retry failed compilations.)

   316   bool failing() { return _failure_reason != NULL; }

   317 

   318   // Reason this compilation is failing, such as "too many basic blocks".

   319   const char* failure_reason() { return _failure_reason; }

   320 

   321   // Return state of appropriate compilability

   322   int compilable() { return _compilable; }

   323 

   324   const char* retry_message() const {

   325     switch (_compilable) {

   326       case ciEnv::MethodCompilable_not_at_tier:

   327         return "retry at different tier";

   328       case ciEnv::MethodCompilable_never:

   329         return "not retryable";

   330       case ciEnv::MethodCompilable:

   331         return NULL;

   332       default:

   333         ShouldNotReachHere();

   334         return NULL;

   335     }

   336   }

   337 

   338   bool break_at_compile() { return _break_at_compile; }

   339   void set_break_at_compile(bool z) { _break_at_compile = z; }

   340 

   341   // Cache Jvmti state

   342   void  cache_jvmti_state();

   343   bool  jvmti_state_changed() const;

   344   bool  should_retain_local_variables() const;

   345   bool  jvmti_can_hotswap_or_post_breakpoint() const { return _jvmti_can_hotswap_or_post_breakpoint; }

   346   bool  jvmti_can_post_on_exceptions()         const { return _jvmti_can_post_on_exceptions; }

   347 

   348   // Cache DTrace flags

   349   void  cache_dtrace_flags();

   350   bool  dtrace_extended_probes() const { return _dtrace_extended_probes; }

   351   bool  dtrace_monitor_probes()  const { return _dtrace_monitor_probes; }

   352   bool  dtrace_method_probes()   const { return _dtrace_method_probes; }

   353   bool  dtrace_alloc_probes()    const { return _dtrace_alloc_probes; }

   354 

   355   // The compiler task which has created this env.

   356   // May be useful to find out compile_id, comp_level, etc.

   357   CompileTask* task() { return _task; }

   358 

   359   // Handy forwards to the task:

   360   int comp_level();   // task()->comp_level()

   361   uint compile_id();  // task()->compile_id()

   362 

   363   // Register the result of a compilation.

   364   void register_method(ciMethod*                 target,

   365                        int                       entry_bci,

   366                        CodeOffsets*              offsets,

   367                        int                       orig_pc_offset,

   368                        CodeBuffer*               code_buffer,

   369                        int                       frame_words,

   370                        OopMapSet*                oop_map_set,

   371                        ExceptionHandlerTable*    handler_table,

   372                        ImplicitExceptionTable*   inc_table,

   373                        AbstractCompiler*         compiler,

   374                        bool                      has_unsafe_access,

   375                        bool                      has_wide_vectors,

   376                        RTMState                  rtm_state = NoRTM);

   377 

   378 

   379   // Access to certain well known ciObjects.

   380 #define WK_KLASS_FUNC(name, ignore_s, ignore_o) \

   381   ciInstanceKlass* name() { \

   382     return _##name;\

   383   }

   384   WK_KLASSES_DO(WK_KLASS_FUNC)

   385 #undef WK_KLASS_FUNC

   386 

   387   ciInstance* NullPointerException_instance() {

   388     assert(_NullPointerException_instance != NULL, "initialization problem");

   389     return _NullPointerException_instance;

   390   }

   391   ciInstance* ArithmeticException_instance() {

   392     assert(_ArithmeticException_instance != NULL, "initialization problem");

   393     return _ArithmeticException_instance;

   394   }

   395 

   396   // Lazy constructors:

   397   ciInstance* ArrayIndexOutOfBoundsException_instance();

   398   ciInstance* ArrayStoreException_instance();

   399   ciInstance* ClassCastException_instance();

   400 

   401   ciInstance* the_null_string();

   402   ciInstance* the_min_jint_string();

   403 

   404   static ciSymbol* unloaded_cisymbol() {

   405     return _unloaded_cisymbol;

   406   }

   407   static ciObjArrayKlass* unloaded_ciobjarrayklass() {

   408     return _unloaded_ciobjarrayklass;

   409   }

   410   static ciInstanceKlass* unloaded_ciinstance_klass() {

   411     return _unloaded_ciinstance_klass;

   412   }

   413   ciInstance* unloaded_ciinstance();

   414 

   415   ciKlass*  find_system_klass(ciSymbol* klass_name);

   416   // Note:  To find a class from its name string, use ciSymbol::make,

   417   // but consider adding to vmSymbols.hpp instead.

   418 

   419   // converts the ciKlass* representing the holder of a method into a

   420   // ciInstanceKlass*.  This is needed since the holder of a method in

   421   // the bytecodes could be an array type.  Basically this converts

   422   // array types into java/lang/Object and other types stay as they are.

   423   static ciInstanceKlass* get_instance_klass_for_declared_method_holder(ciKlass* klass);

   424 

   425   // Return the machine-level offset of o, which must be an element of a.

   426   // This may be used to form constant-loading expressions in lieu of simpler encodings.

   427   int       array_element_offset_in_bytes(ciArray* a, ciObject* o);

   428 

   429   // Access to the compile-lifetime allocation arena.

   430   Arena*    arena() { return _arena; }

   431 

   432   // What is the current compilation environment?

   433   static ciEnv* current() { return CompilerThread::current()->env(); }

   434 

   435   // Overload with current thread argument

   436   static ciEnv* current(CompilerThread *thread) { return thread->env(); }

   437 

   438   // Per-compiler data.  (Used by C2 to publish the Compile* pointer.)

   439   void* compiler_data() { return _compiler_data; }

   440   void set_compiler_data(void* x) { _compiler_data = x; }

   441 

   442   // Notice that a method has been inlined in the current compile;

   443   // used only for statistics.

   444   void notice_inlined_method(ciMethod* method);

   445 

   446   // Total number of bytecodes in inlined methods in this compile

   447   int num_inlined_bytecodes() const;

   448 

   449   // Output stream for logging compilation info.

   450   CompileLog* log() { return _log; }

   451   void set_log(CompileLog* log) { _log = log; }

   452 

   453   // Check for changes to the system dictionary during compilation

   454   bool system_dictionary_modification_counter_changed();

   455 

   456   void record_failure(const char* reason);      // Record failure and report later

   457   void report_failure(const char* reason);      // Report failure immediately

   458   void record_method_not_compilable(const char* reason, bool all_tiers = true);

   459   void record_out_of_memory_failure();

   460 

   461   // RedefineClasses support

   462   void metadata_do(void f(Metadata*)) { _factory->metadata_do(f); }

   463 

   464   // Dump the compilation replay data for the ciEnv to the stream.

   465   void dump_replay_data(int compile_id);

   466   void dump_inline_data(int compile_id);

   467   void dump_replay_data(outputStream* out);

   468   void dump_replay_data_unsafe(outputStream* out);

   469   void dump_compile_data(outputStream* out);

   470 };

   471 

   472 #endif // SHARE_VM_CI_CIENV_HPP