Mon, 26 Apr 2010 23:59:45 -0700
6943485: JVMTI always on capabilities change code generation too much
Reviewed-by: twisti, dcubed
duke@435 | 1 | /* |
dcubed@1648 | 2 | * Copyright 1999-2010 Sun Microsystems, Inc. All Rights Reserved. |
duke@435 | 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
duke@435 | 4 | * |
duke@435 | 5 | * This code is free software; you can redistribute it and/or modify it |
duke@435 | 6 | * under the terms of the GNU General Public License version 2 only, as |
duke@435 | 7 | * published by the Free Software Foundation. |
duke@435 | 8 | * |
duke@435 | 9 | * This code is distributed in the hope that it will be useful, but WITHOUT |
duke@435 | 10 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
duke@435 | 11 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
duke@435 | 12 | * version 2 for more details (a copy is included in the LICENSE file that |
duke@435 | 13 | * accompanied this code). |
duke@435 | 14 | * |
duke@435 | 15 | * You should have received a copy of the GNU General Public License version |
duke@435 | 16 | * 2 along with this work; if not, write to the Free Software Foundation, |
duke@435 | 17 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
duke@435 | 18 | * |
duke@435 | 19 | * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
duke@435 | 20 | * CA 95054 USA or visit www.sun.com if you need additional information or |
duke@435 | 21 | * have any questions. |
duke@435 | 22 | * |
duke@435 | 23 | */ |
duke@435 | 24 | |
duke@435 | 25 | class CompileTask; |
duke@435 | 26 | |
duke@435 | 27 | // ciEnv |
duke@435 | 28 | // |
duke@435 | 29 | // This class is the top level broker for requests from the compiler |
duke@435 | 30 | // to the VM. |
duke@435 | 31 | class ciEnv : StackObj { |
duke@435 | 32 | CI_PACKAGE_ACCESS_TO |
duke@435 | 33 | |
duke@435 | 34 | friend class CompileBroker; |
duke@435 | 35 | friend class Dependencies; // for get_object, during logging |
duke@435 | 36 | |
duke@435 | 37 | private: |
duke@435 | 38 | Arena* _arena; // Alias for _ciEnv_arena except in init_shared_objects() |
duke@435 | 39 | Arena _ciEnv_arena; |
duke@435 | 40 | int _system_dictionary_modification_counter; |
duke@435 | 41 | ciObjectFactory* _factory; |
duke@435 | 42 | OopRecorder* _oop_recorder; |
duke@435 | 43 | DebugInformationRecorder* _debug_info; |
duke@435 | 44 | Dependencies* _dependencies; |
duke@435 | 45 | const char* _failure_reason; |
duke@435 | 46 | int _compilable; |
duke@435 | 47 | bool _break_at_compile; |
duke@435 | 48 | int _num_inlined_bytecodes; |
duke@435 | 49 | CompileTask* _task; // faster access to CompilerThread::task |
duke@435 | 50 | CompileLog* _log; // faster access to CompilerThread::log |
duke@435 | 51 | void* _compiler_data; // compiler-specific stuff, if any |
duke@435 | 52 | |
duke@435 | 53 | char* _name_buffer; |
duke@435 | 54 | int _name_buffer_len; |
duke@435 | 55 | |
kvn@1215 | 56 | // Cache Jvmti state |
kvn@1215 | 57 | bool _jvmti_can_hotswap_or_post_breakpoint; |
kvn@1215 | 58 | bool _jvmti_can_access_local_variables; |
dcubed@1648 | 59 | bool _jvmti_can_post_on_exceptions; |
kvn@1215 | 60 | |
kvn@1215 | 61 | // Cache DTrace flags |
kvn@1215 | 62 | bool _dtrace_extended_probes; |
kvn@1215 | 63 | bool _dtrace_monitor_probes; |
kvn@1215 | 64 | bool _dtrace_method_probes; |
kvn@1215 | 65 | bool _dtrace_alloc_probes; |
kvn@1215 | 66 | |
duke@435 | 67 | // Distinguished instances of certain ciObjects.. |
duke@435 | 68 | static ciObject* _null_object_instance; |
duke@435 | 69 | static ciMethodKlass* _method_klass_instance; |
duke@435 | 70 | static ciSymbolKlass* _symbol_klass_instance; |
duke@435 | 71 | static ciKlassKlass* _klass_klass_instance; |
duke@435 | 72 | static ciInstanceKlassKlass* _instance_klass_klass_instance; |
duke@435 | 73 | static ciTypeArrayKlassKlass* _type_array_klass_klass_instance; |
duke@435 | 74 | static ciObjArrayKlassKlass* _obj_array_klass_klass_instance; |
duke@435 | 75 | |
never@1577 | 76 | #define WK_KLASS_DECL(name, ignore_s, ignore_o) static ciInstanceKlass* _##name; |
never@1577 | 77 | WK_KLASSES_DO(WK_KLASS_DECL) |
never@1577 | 78 | #undef WK_KLASS_DECL |
duke@435 | 79 | |
duke@435 | 80 | static ciSymbol* _unloaded_cisymbol; |
duke@435 | 81 | static ciInstanceKlass* _unloaded_ciinstance_klass; |
duke@435 | 82 | static ciObjArrayKlass* _unloaded_ciobjarrayklass; |
duke@435 | 83 | |
duke@435 | 84 | static jobject _ArrayIndexOutOfBoundsException_handle; |
duke@435 | 85 | static jobject _ArrayStoreException_handle; |
duke@435 | 86 | static jobject _ClassCastException_handle; |
duke@435 | 87 | |
duke@435 | 88 | ciInstance* _NullPointerException_instance; |
duke@435 | 89 | ciInstance* _ArithmeticException_instance; |
duke@435 | 90 | ciInstance* _ArrayIndexOutOfBoundsException_instance; |
duke@435 | 91 | ciInstance* _ArrayStoreException_instance; |
duke@435 | 92 | ciInstance* _ClassCastException_instance; |
duke@435 | 93 | |
never@1515 | 94 | ciInstance* _the_null_string; // The Java string "null" |
never@1515 | 95 | ciInstance* _the_min_jint_string; // The Java string "-2147483648" |
never@1515 | 96 | |
duke@435 | 97 | // Look up a klass by name from a particular class loader (the accessor's). |
duke@435 | 98 | // If require_local, result must be defined in that class loader, or NULL. |
duke@435 | 99 | // If !require_local, a result from remote class loader may be reported, |
duke@435 | 100 | // if sufficient class loader constraints exist such that initiating |
duke@435 | 101 | // a class loading request from the given loader is bound to return |
duke@435 | 102 | // the class defined in the remote loader (or throw an error). |
duke@435 | 103 | // |
duke@435 | 104 | // Return an unloaded klass if !require_local and no class at all is found. |
duke@435 | 105 | // |
duke@435 | 106 | // The CI treats a klass as loaded if it is consistently defined in |
duke@435 | 107 | // another loader, even if it hasn't yet been loaded in all loaders |
duke@435 | 108 | // that could potentially see it via delegation. |
duke@435 | 109 | ciKlass* get_klass_by_name(ciKlass* accessing_klass, |
duke@435 | 110 | ciSymbol* klass_name, |
duke@435 | 111 | bool require_local); |
duke@435 | 112 | |
duke@435 | 113 | // Constant pool access. |
twisti@1573 | 114 | ciKlass* get_klass_by_index(constantPoolHandle cpool, |
duke@435 | 115 | int klass_index, |
twisti@1573 | 116 | bool& is_accessible, |
twisti@1573 | 117 | ciInstanceKlass* loading_klass); |
twisti@1573 | 118 | ciConstant get_constant_by_index(constantPoolHandle cpool, |
twisti@1573 | 119 | int constant_index, |
twisti@1573 | 120 | ciInstanceKlass* accessor); |
duke@435 | 121 | bool is_unresolved_string(ciInstanceKlass* loading_klass, |
duke@435 | 122 | int constant_index) const; |
duke@435 | 123 | bool is_unresolved_klass(ciInstanceKlass* loading_klass, |
duke@435 | 124 | int constant_index) const; |
duke@435 | 125 | ciField* get_field_by_index(ciInstanceKlass* loading_klass, |
duke@435 | 126 | int field_index); |
twisti@1573 | 127 | ciMethod* get_method_by_index(constantPoolHandle cpool, |
twisti@1573 | 128 | int method_index, Bytecodes::Code bc, |
twisti@1573 | 129 | ciInstanceKlass* loading_klass); |
duke@435 | 130 | |
duke@435 | 131 | // Implementation methods for loading and constant pool access. |
duke@435 | 132 | ciKlass* get_klass_by_name_impl(ciKlass* accessing_klass, |
duke@435 | 133 | ciSymbol* klass_name, |
duke@435 | 134 | bool require_local); |
twisti@1573 | 135 | ciKlass* get_klass_by_index_impl(constantPoolHandle cpool, |
duke@435 | 136 | int klass_index, |
twisti@1573 | 137 | bool& is_accessible, |
twisti@1573 | 138 | ciInstanceKlass* loading_klass); |
twisti@1573 | 139 | ciConstant get_constant_by_index_impl(constantPoolHandle cpool, |
twisti@1573 | 140 | int constant_index, |
twisti@1573 | 141 | ciInstanceKlass* loading_klass); |
duke@435 | 142 | bool is_unresolved_string_impl (instanceKlass* loading_klass, |
duke@435 | 143 | int constant_index) const; |
duke@435 | 144 | bool is_unresolved_klass_impl (instanceKlass* loading_klass, |
duke@435 | 145 | int constant_index) const; |
duke@435 | 146 | ciField* get_field_by_index_impl(ciInstanceKlass* loading_klass, |
duke@435 | 147 | int field_index); |
twisti@1573 | 148 | ciMethod* get_method_by_index_impl(constantPoolHandle cpool, |
twisti@1573 | 149 | int method_index, Bytecodes::Code bc, |
twisti@1573 | 150 | ciInstanceKlass* loading_klass); |
twisti@1573 | 151 | ciMethod* get_fake_invokedynamic_method_impl(constantPoolHandle cpool, |
twisti@1572 | 152 | int index, Bytecodes::Code bc); |
duke@435 | 153 | |
duke@435 | 154 | // Helper methods |
duke@435 | 155 | bool check_klass_accessibility(ciKlass* accessing_klass, |
duke@435 | 156 | klassOop resolved_klassOop); |
duke@435 | 157 | methodOop lookup_method(instanceKlass* accessor, |
duke@435 | 158 | instanceKlass* holder, |
duke@435 | 159 | symbolOop name, |
duke@435 | 160 | symbolOop sig, |
duke@435 | 161 | Bytecodes::Code bc); |
duke@435 | 162 | |
duke@435 | 163 | // Get a ciObject from the object factory. Ensures uniqueness |
duke@435 | 164 | // of ciObjects. |
duke@435 | 165 | ciObject* get_object(oop o) { |
duke@435 | 166 | if (o == NULL) { |
duke@435 | 167 | return _null_object_instance; |
duke@435 | 168 | } else { |
duke@435 | 169 | return _factory->get(o); |
duke@435 | 170 | } |
duke@435 | 171 | } |
duke@435 | 172 | |
duke@435 | 173 | ciMethod* get_method_from_handle(jobject method); |
duke@435 | 174 | |
duke@435 | 175 | ciInstance* get_or_create_exception(jobject& handle, symbolHandle name); |
duke@435 | 176 | |
duke@435 | 177 | // Get a ciMethod representing either an unfound method or |
duke@435 | 178 | // a method with an unloaded holder. Ensures uniqueness of |
duke@435 | 179 | // the result. |
duke@435 | 180 | ciMethod* get_unloaded_method(ciInstanceKlass* holder, |
duke@435 | 181 | ciSymbol* name, |
duke@435 | 182 | ciSymbol* signature) { |
duke@435 | 183 | return _factory->get_unloaded_method(holder, name, signature); |
duke@435 | 184 | } |
duke@435 | 185 | |
duke@435 | 186 | // Get a ciKlass representing an unloaded klass. |
duke@435 | 187 | // Ensures uniqueness of the result. |
duke@435 | 188 | ciKlass* get_unloaded_klass(ciKlass* accessing_klass, |
duke@435 | 189 | ciSymbol* name) { |
duke@435 | 190 | return _factory->get_unloaded_klass(accessing_klass, name, true); |
duke@435 | 191 | } |
duke@435 | 192 | |
duke@435 | 193 | // See if we already have an unloaded klass for the given name |
duke@435 | 194 | // or return NULL if not. |
duke@435 | 195 | ciKlass *check_get_unloaded_klass(ciKlass* accessing_klass, ciSymbol* name) { |
duke@435 | 196 | return _factory->get_unloaded_klass(accessing_klass, name, false); |
duke@435 | 197 | } |
duke@435 | 198 | |
duke@435 | 199 | // Get a ciReturnAddress corresponding to the given bci. |
duke@435 | 200 | // Ensures uniqueness of the result. |
duke@435 | 201 | ciReturnAddress* get_return_address(int bci) { |
duke@435 | 202 | return _factory->get_return_address(bci); |
duke@435 | 203 | } |
duke@435 | 204 | |
duke@435 | 205 | // Get a ciMethodData representing the methodData for a method |
duke@435 | 206 | // with none. |
duke@435 | 207 | ciMethodData* get_empty_methodData() { |
duke@435 | 208 | return _factory->get_empty_methodData(); |
duke@435 | 209 | } |
duke@435 | 210 | |
duke@435 | 211 | // General utility : get a buffer of some required length. |
duke@435 | 212 | // Used in symbol creation. |
duke@435 | 213 | char* name_buffer(int req_len); |
duke@435 | 214 | |
duke@435 | 215 | // Is this thread currently in the VM state? |
duke@435 | 216 | static bool is_in_vm(); |
duke@435 | 217 | |
duke@435 | 218 | // Helper routine for determining the validity of a compilation |
duke@435 | 219 | // with respect to concurrent class loading. |
duke@435 | 220 | void check_for_system_dictionary_modification(ciMethod* target); |
duke@435 | 221 | |
duke@435 | 222 | public: |
duke@435 | 223 | enum { |
duke@435 | 224 | MethodCompilable, |
duke@435 | 225 | MethodCompilable_not_at_tier, |
duke@435 | 226 | MethodCompilable_never |
duke@435 | 227 | }; |
duke@435 | 228 | |
duke@435 | 229 | ciEnv(CompileTask* task, int system_dictionary_modification_counter); |
duke@435 | 230 | // Used only during initialization of the ci |
duke@435 | 231 | ciEnv(Arena* arena); |
duke@435 | 232 | ~ciEnv(); |
duke@435 | 233 | |
duke@435 | 234 | OopRecorder* oop_recorder() { return _oop_recorder; } |
duke@435 | 235 | void set_oop_recorder(OopRecorder* r) { _oop_recorder = r; } |
duke@435 | 236 | |
duke@435 | 237 | DebugInformationRecorder* debug_info() { return _debug_info; } |
duke@435 | 238 | void set_debug_info(DebugInformationRecorder* i) { _debug_info = i; } |
duke@435 | 239 | |
duke@435 | 240 | Dependencies* dependencies() { return _dependencies; } |
duke@435 | 241 | void set_dependencies(Dependencies* d) { _dependencies = d; } |
duke@435 | 242 | |
duke@435 | 243 | // This is true if the compilation is not going to produce code. |
duke@435 | 244 | // (It is reasonable to retry failed compilations.) |
duke@435 | 245 | bool failing() { return _failure_reason != NULL; } |
duke@435 | 246 | |
duke@435 | 247 | // Reason this compilation is failing, such as "too many basic blocks". |
duke@435 | 248 | const char* failure_reason() { return _failure_reason; } |
duke@435 | 249 | |
duke@435 | 250 | // Return state of appropriate compilability |
duke@435 | 251 | int compilable() { return _compilable; } |
duke@435 | 252 | |
duke@435 | 253 | bool break_at_compile() { return _break_at_compile; } |
duke@435 | 254 | void set_break_at_compile(bool z) { _break_at_compile = z; } |
duke@435 | 255 | |
kvn@1215 | 256 | // Cache Jvmti state |
kvn@1215 | 257 | void cache_jvmti_state(); |
kvn@1215 | 258 | bool jvmti_can_hotswap_or_post_breakpoint() const { return _jvmti_can_hotswap_or_post_breakpoint; } |
kvn@1215 | 259 | bool jvmti_can_access_local_variables() const { return _jvmti_can_access_local_variables; } |
dcubed@1648 | 260 | bool jvmti_can_post_on_exceptions() const { return _jvmti_can_post_on_exceptions; } |
kvn@1215 | 261 | |
kvn@1215 | 262 | // Cache DTrace flags |
kvn@1215 | 263 | void cache_dtrace_flags(); |
kvn@1215 | 264 | bool dtrace_extended_probes() const { return _dtrace_extended_probes; } |
kvn@1215 | 265 | bool dtrace_monitor_probes() const { return _dtrace_monitor_probes; } |
kvn@1215 | 266 | bool dtrace_method_probes() const { return _dtrace_method_probes; } |
kvn@1215 | 267 | bool dtrace_alloc_probes() const { return _dtrace_alloc_probes; } |
kvn@1215 | 268 | |
duke@435 | 269 | // The compiler task which has created this env. |
duke@435 | 270 | // May be useful to find out compile_id, comp_level, etc. |
duke@435 | 271 | CompileTask* task() { return _task; } |
duke@435 | 272 | // Handy forwards to the task: |
duke@435 | 273 | int comp_level(); // task()->comp_level() |
duke@435 | 274 | uint compile_id(); // task()->compile_id() |
duke@435 | 275 | |
duke@435 | 276 | // Register the result of a compilation. |
duke@435 | 277 | void register_method(ciMethod* target, |
duke@435 | 278 | int entry_bci, |
duke@435 | 279 | CodeOffsets* offsets, |
duke@435 | 280 | int orig_pc_offset, |
duke@435 | 281 | CodeBuffer* code_buffer, |
duke@435 | 282 | int frame_words, |
duke@435 | 283 | OopMapSet* oop_map_set, |
duke@435 | 284 | ExceptionHandlerTable* handler_table, |
duke@435 | 285 | ImplicitExceptionTable* inc_table, |
duke@435 | 286 | AbstractCompiler* compiler, |
duke@435 | 287 | int comp_level, |
duke@435 | 288 | bool has_debug_info = true, |
duke@435 | 289 | bool has_unsafe_access = false); |
duke@435 | 290 | |
duke@435 | 291 | |
duke@435 | 292 | // Access to certain well known ciObjects. |
never@1577 | 293 | #define WK_KLASS_FUNC(name, ignore_s, ignore_o) \ |
never@1577 | 294 | ciInstanceKlass* name() { \ |
never@1577 | 295 | return _##name;\ |
duke@435 | 296 | } |
never@1577 | 297 | WK_KLASSES_DO(WK_KLASS_FUNC) |
never@1577 | 298 | #undef WK_KLASS_FUNC |
never@1577 | 299 | |
duke@435 | 300 | ciInstance* NullPointerException_instance() { |
duke@435 | 301 | assert(_NullPointerException_instance != NULL, "initialization problem"); |
duke@435 | 302 | return _NullPointerException_instance; |
duke@435 | 303 | } |
duke@435 | 304 | ciInstance* ArithmeticException_instance() { |
duke@435 | 305 | assert(_ArithmeticException_instance != NULL, "initialization problem"); |
duke@435 | 306 | return _ArithmeticException_instance; |
duke@435 | 307 | } |
duke@435 | 308 | |
duke@435 | 309 | // Lazy constructors: |
duke@435 | 310 | ciInstance* ArrayIndexOutOfBoundsException_instance(); |
duke@435 | 311 | ciInstance* ArrayStoreException_instance(); |
duke@435 | 312 | ciInstance* ClassCastException_instance(); |
duke@435 | 313 | |
never@1515 | 314 | ciInstance* the_null_string(); |
never@1515 | 315 | ciInstance* the_min_jint_string(); |
never@1515 | 316 | |
duke@435 | 317 | static ciSymbol* unloaded_cisymbol() { |
duke@435 | 318 | return _unloaded_cisymbol; |
duke@435 | 319 | } |
duke@435 | 320 | static ciObjArrayKlass* unloaded_ciobjarrayklass() { |
duke@435 | 321 | return _unloaded_ciobjarrayklass; |
duke@435 | 322 | } |
duke@435 | 323 | static ciInstanceKlass* unloaded_ciinstance_klass() { |
duke@435 | 324 | return _unloaded_ciinstance_klass; |
duke@435 | 325 | } |
duke@435 | 326 | |
duke@435 | 327 | ciKlass* find_system_klass(ciSymbol* klass_name); |
duke@435 | 328 | // Note: To find a class from its name string, use ciSymbol::make, |
duke@435 | 329 | // but consider adding to vmSymbols.hpp instead. |
duke@435 | 330 | |
duke@435 | 331 | // Use this to make a holder for non-perm compile time constants. |
jrose@1424 | 332 | // The resulting array is guaranteed to satisfy "can_be_constant". |
jrose@1424 | 333 | ciArray* make_system_array(GrowableArray<ciObject*>* objects); |
duke@435 | 334 | |
duke@435 | 335 | // converts the ciKlass* representing the holder of a method into a |
duke@435 | 336 | // ciInstanceKlass*. This is needed since the holder of a method in |
duke@435 | 337 | // the bytecodes could be an array type. Basically this converts |
duke@435 | 338 | // array types into java/lang/Object and other types stay as they are. |
duke@435 | 339 | static ciInstanceKlass* get_instance_klass_for_declared_method_holder(ciKlass* klass); |
duke@435 | 340 | |
duke@435 | 341 | // Return the machine-level offset of o, which must be an element of a. |
duke@435 | 342 | // This may be used to form constant-loading expressions in lieu of simpler encodings. |
duke@435 | 343 | int array_element_offset_in_bytes(ciArray* a, ciObject* o); |
duke@435 | 344 | |
duke@435 | 345 | // Access to the compile-lifetime allocation arena. |
duke@435 | 346 | Arena* arena() { return _arena; } |
duke@435 | 347 | |
duke@435 | 348 | // What is the current compilation environment? |
duke@435 | 349 | static ciEnv* current() { return CompilerThread::current()->env(); } |
duke@435 | 350 | |
duke@435 | 351 | // Overload with current thread argument |
duke@435 | 352 | static ciEnv* current(CompilerThread *thread) { return thread->env(); } |
duke@435 | 353 | |
duke@435 | 354 | // Per-compiler data. (Used by C2 to publish the Compile* pointer.) |
duke@435 | 355 | void* compiler_data() { return _compiler_data; } |
duke@435 | 356 | void set_compiler_data(void* x) { _compiler_data = x; } |
duke@435 | 357 | |
duke@435 | 358 | // Notice that a method has been inlined in the current compile; |
duke@435 | 359 | // used only for statistics. |
duke@435 | 360 | void notice_inlined_method(ciMethod* method); |
duke@435 | 361 | |
duke@435 | 362 | // Total number of bytecodes in inlined methods in this compile |
duke@435 | 363 | int num_inlined_bytecodes() const; |
duke@435 | 364 | |
duke@435 | 365 | // Output stream for logging compilation info. |
duke@435 | 366 | CompileLog* log() { return _log; } |
duke@435 | 367 | void set_log(CompileLog* log) { _log = log; } |
duke@435 | 368 | |
duke@435 | 369 | // Check for changes to the system dictionary during compilation |
duke@435 | 370 | bool system_dictionary_modification_counter_changed(); |
duke@435 | 371 | |
duke@435 | 372 | void record_failure(const char* reason); |
duke@435 | 373 | void record_method_not_compilable(const char* reason, bool all_tiers = true); |
duke@435 | 374 | void record_out_of_memory_failure(); |
duke@435 | 375 | }; |