truffle: src/share/vm/ci/ciEnv.hpp annotate

annotate src/share/vm/ci/ciEnv.hpp @ 6972:bd7a7ce2e264

6830717: replay of compilations would help with debugging Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method. Reviewed-by: kvn, twisti, sspitsyn Contributed-by: yumin.qi@oracle.com

author	minqi
date	Mon, 12 Nov 2012 14:03:53 -0800
parents	137868b7aa6f
children	2cb439954abf e12c9b3740db

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	2 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1397 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1397 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1397 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	25 #ifndef SHARE_VM_CI_CIENV_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	26 #define SHARE_VM_CI_CIENV_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	28 #include "ci/ciClassList.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	29 #include "ci/ciObjectFactory.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	30 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	31 #include "code/debugInfoRec.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	32 #include "code/dependencies.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	33 #include "code/exceptionHandlerTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	34 #include "compiler/oopMap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	35 #include "runtime/thread.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	36
0 a61af66fc99e Initial load duke parents: diff changeset	37 class CompileTask;
a61af66fc99e Initial load duke parents: diff changeset	38
a61af66fc99e Initial load duke parents: diff changeset	39 // ciEnv
a61af66fc99e Initial load duke parents: diff changeset	40 //
a61af66fc99e Initial load duke parents: diff changeset	41 // This class is the top level broker for requests from the compiler
a61af66fc99e Initial load duke parents: diff changeset	42 // to the VM.
a61af66fc99e Initial load duke parents: diff changeset	43 class ciEnv : StackObj {
a61af66fc99e Initial load duke parents: diff changeset	44 CI_PACKAGE_ACCESS_TO
a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 friend class CompileBroker;
a61af66fc99e Initial load duke parents: diff changeset	47 friend class Dependencies; // for get_object, during logging
a61af66fc99e Initial load duke parents: diff changeset	48
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	49 static fileStream* _replay_data_stream;
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	50
0 a61af66fc99e Initial load duke parents: diff changeset	51 private:
a61af66fc99e Initial load duke parents: diff changeset	52 Arena* _arena; // Alias for _ciEnv_arena except in init_shared_objects()
a61af66fc99e Initial load duke parents: diff changeset	53 Arena _ciEnv_arena;
a61af66fc99e Initial load duke parents: diff changeset	54 int _system_dictionary_modification_counter;
a61af66fc99e Initial load duke parents: diff changeset	55 ciObjectFactory* _factory;
a61af66fc99e Initial load duke parents: diff changeset	56 OopRecorder* _oop_recorder;
a61af66fc99e Initial load duke parents: diff changeset	57 DebugInformationRecorder* _debug_info;
a61af66fc99e Initial load duke parents: diff changeset	58 Dependencies* _dependencies;
a61af66fc99e Initial load duke parents: diff changeset	59 const char* _failure_reason;
a61af66fc99e Initial load duke parents: diff changeset	60 int _compilable;
a61af66fc99e Initial load duke parents: diff changeset	61 bool _break_at_compile;
a61af66fc99e Initial load duke parents: diff changeset	62 int _num_inlined_bytecodes;
a61af66fc99e Initial load duke parents: diff changeset	63 CompileTask* _task; // faster access to CompilerThread::task
a61af66fc99e Initial load duke parents: diff changeset	64 CompileLog* _log; // faster access to CompilerThread::log
a61af66fc99e Initial load duke parents: diff changeset	65 void* _compiler_data; // compiler-specific stuff, if any
a61af66fc99e Initial load duke parents: diff changeset	66
a61af66fc99e Initial load duke parents: diff changeset	67 char* _name_buffer;
a61af66fc99e Initial load duke parents: diff changeset	68 int _name_buffer_len;
a61af66fc99e Initial load duke parents: diff changeset	69
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	70 // Cache Jvmti state
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	71 bool _jvmti_can_hotswap_or_post_breakpoint;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	72 bool _jvmti_can_access_local_variables;
1213 6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty dcubed parents: 1142 diff changeset	73 bool _jvmti_can_post_on_exceptions;
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	74
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	75 // Cache DTrace flags
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	76 bool _dtrace_extended_probes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	77 bool _dtrace_monitor_probes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	78 bool _dtrace_method_probes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	79 bool _dtrace_alloc_probes;
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	80
0 a61af66fc99e Initial load duke parents: diff changeset	81 // Distinguished instances of certain ciObjects..
a61af66fc99e Initial load duke parents: diff changeset	82 static ciObject* _null_object_instance;
a61af66fc99e Initial load duke parents: diff changeset	83
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	84 #define WK_KLASS_DECL(name, ignore_s, ignore_o) static ciInstanceKlass* _##name;
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	85 WK_KLASSES_DO(WK_KLASS_DECL)
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	86 #undef WK_KLASS_DECL
0 a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 static ciSymbol* _unloaded_cisymbol;
a61af66fc99e Initial load duke parents: diff changeset	89 static ciInstanceKlass* _unloaded_ciinstance_klass;
a61af66fc99e Initial load duke parents: diff changeset	90 static ciObjArrayKlass* _unloaded_ciobjarrayklass;
a61af66fc99e Initial load duke parents: diff changeset	91
a61af66fc99e Initial load duke parents: diff changeset	92 static jobject _ArrayIndexOutOfBoundsException_handle;
a61af66fc99e Initial load duke parents: diff changeset	93 static jobject _ArrayStoreException_handle;
a61af66fc99e Initial load duke parents: diff changeset	94 static jobject _ClassCastException_handle;
a61af66fc99e Initial load duke parents: diff changeset	95
a61af66fc99e Initial load duke parents: diff changeset	96 ciInstance* _NullPointerException_instance;
a61af66fc99e Initial load duke parents: diff changeset	97 ciInstance* _ArithmeticException_instance;
a61af66fc99e Initial load duke parents: diff changeset	98 ciInstance* _ArrayIndexOutOfBoundsException_instance;
a61af66fc99e Initial load duke parents: diff changeset	99 ciInstance* _ArrayStoreException_instance;
a61af66fc99e Initial load duke parents: diff changeset	100 ciInstance* _ClassCastException_instance;
a61af66fc99e Initial load duke parents: diff changeset	101
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	102 ciInstance* _the_null_string; // The Java string "null"
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	103 ciInstance* _the_min_jint_string; // The Java string "-2147483648"
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	104
0 a61af66fc99e Initial load duke parents: diff changeset	105 // Look up a klass by name from a particular class loader (the accessor's).
a61af66fc99e Initial load duke parents: diff changeset	106 // If require_local, result must be defined in that class loader, or NULL.
a61af66fc99e Initial load duke parents: diff changeset	107 // If !require_local, a result from remote class loader may be reported,
a61af66fc99e Initial load duke parents: diff changeset	108 // if sufficient class loader constraints exist such that initiating
a61af66fc99e Initial load duke parents: diff changeset	109 // a class loading request from the given loader is bound to return
a61af66fc99e Initial load duke parents: diff changeset	110 // the class defined in the remote loader (or throw an error).
a61af66fc99e Initial load duke parents: diff changeset	111 //
a61af66fc99e Initial load duke parents: diff changeset	112 // Return an unloaded klass if !require_local and no class at all is found.
a61af66fc99e Initial load duke parents: diff changeset	113 //
a61af66fc99e Initial load duke parents: diff changeset	114 // The CI treats a klass as loaded if it is consistently defined in
a61af66fc99e Initial load duke parents: diff changeset	115 // another loader, even if it hasn't yet been loaded in all loaders
a61af66fc99e Initial load duke parents: diff changeset	116 // that could potentially see it via delegation.
a61af66fc99e Initial load duke parents: diff changeset	117 ciKlass* get_klass_by_name(ciKlass* accessing_klass,
a61af66fc99e Initial load duke parents: diff changeset	118 ciSymbol* klass_name,
a61af66fc99e Initial load duke parents: diff changeset	119 bool require_local);
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // Constant pool access.
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	122 ciKlass* get_klass_by_index(constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	123 int klass_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	124 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	125 ciInstanceKlass* loading_klass);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	126 ciConstant get_constant_by_index(constantPoolHandle cpool,
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	127 int pool_index, int cache_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	128 ciInstanceKlass* accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	129 ciField* get_field_by_index(ciInstanceKlass* loading_klass,
a61af66fc99e Initial load duke parents: diff changeset	130 int field_index);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	131 ciMethod* get_method_by_index(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	132 int method_index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	133 ciInstanceKlass* loading_klass);
0 a61af66fc99e Initial load duke parents: diff changeset	134
a61af66fc99e Initial load duke parents: diff changeset	135 // Implementation methods for loading and constant pool access.
a61af66fc99e Initial load duke parents: diff changeset	136 ciKlass* get_klass_by_name_impl(ciKlass* accessing_klass,
3785 ddd894528dbc 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path jrose parents: 2426 diff changeset	137 constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	138 ciSymbol* klass_name,
a61af66fc99e Initial load duke parents: diff changeset	139 bool require_local);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	140 ciKlass* get_klass_by_index_impl(constantPoolHandle cpool,
0 a61af66fc99e Initial load duke parents: diff changeset	141 int klass_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	142 bool& is_accessible,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	143 ciInstanceKlass* loading_klass);
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	144 ciConstant get_constant_by_index_impl(constantPoolHandle cpool,
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	145 int pool_index, int cache_index,
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	146 ciInstanceKlass* loading_klass);
0 a61af66fc99e Initial load duke parents: diff changeset	147 ciField* get_field_by_index_impl(ciInstanceKlass* loading_klass,
a61af66fc99e Initial load duke parents: diff changeset	148 int field_index);
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	149 ciMethod* get_method_by_index_impl(constantPoolHandle cpool,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	150 int method_index, Bytecodes::Code bc,
dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	151 ciInstanceKlass* loading_klass);
0 a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 // Helper methods
a61af66fc99e Initial load duke parents: diff changeset	154 bool check_klass_accessibility(ciKlass* accessing_klass,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	155 Klass* resolved_klass);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	156 Method* lookup_method(InstanceKlass* accessor,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	157 InstanceKlass* holder,
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	158 Symbol* name,
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	159 Symbol* sig,
0 a61af66fc99e Initial load duke parents: diff changeset	160 Bytecodes::Code bc);
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162 // Get a ciObject from the object factory. Ensures uniqueness
a61af66fc99e Initial load duke parents: diff changeset	163 // of ciObjects.
a61af66fc99e Initial load duke parents: diff changeset	164 ciObject* get_object(oop o) {
a61af66fc99e Initial load duke parents: diff changeset	165 if (o == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	166 return _null_object_instance;
a61af66fc99e Initial load duke parents: diff changeset	167 } else {
a61af66fc99e Initial load duke parents: diff changeset	168 return _factory->get(o);
a61af66fc99e Initial load duke parents: diff changeset	169 }
a61af66fc99e Initial load duke parents: diff changeset	170 }
a61af66fc99e Initial load duke parents: diff changeset	171
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	172 ciSymbol* get_symbol(Symbol* o) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	173 if (o == NULL) {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	174 ShouldNotReachHere();
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	175 return NULL;
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	176 } else {
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	177 return _factory->get_symbol(o);
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	178 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	179 }
3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	180
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	181 ciMetadata* get_metadata(Metadata* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	182 if (o == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	183 return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	184 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	185 return _factory->get_metadata(o);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	186 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	187 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	188
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	189 ciInstance* get_instance(oop o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	190 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	191 return get_object(o)->as_instance();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	192 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	193 ciObjArrayKlass* get_obj_array_klass(Klass* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	194 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	195 return get_metadata(o)->as_obj_array_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	196 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	197 ciTypeArrayKlass* get_type_array_klass(Klass* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	198 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	199 return get_metadata(o)->as_type_array_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	200 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	201 ciKlass* get_klass(Klass* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	202 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	203 return get_metadata(o)->as_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	204 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	205 ciInstanceKlass* get_instance_klass(Klass* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	206 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	207 return get_metadata(o)->as_instance_klass();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	208 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	209 ciMethod* get_method(Method* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	210 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	211 return get_metadata(o)->as_method();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	212 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	213 ciMethodData* get_method_data(MethodData* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	214 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	215 return get_metadata(o)->as_method_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	216 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	217
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	218 ciMethod* get_method_from_handle(Method* method);
0 a61af66fc99e Initial load duke parents: diff changeset	219
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	220 ciInstance* get_or_create_exception(jobject& handle, Symbol* name);
0 a61af66fc99e Initial load duke parents: diff changeset	221
a61af66fc99e Initial load duke parents: diff changeset	222 // Get a ciMethod representing either an unfound method or
a61af66fc99e Initial load duke parents: diff changeset	223 // a method with an unloaded holder. Ensures uniqueness of
a61af66fc99e Initial load duke parents: diff changeset	224 // the result.
a61af66fc99e Initial load duke parents: diff changeset	225 ciMethod* get_unloaded_method(ciInstanceKlass* holder,
a61af66fc99e Initial load duke parents: diff changeset	226 ciSymbol* name,
4001 5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3899 diff changeset	227 ciSymbol* signature,
5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3899 diff changeset	228 ciInstanceKlass* accessor) {
5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3899 diff changeset	229 return _factory->get_unloaded_method(holder, name, signature, accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	230 }
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 // Get a ciKlass representing an unloaded klass.
a61af66fc99e Initial load duke parents: diff changeset	233 // Ensures uniqueness of the result.
4001 5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3899 diff changeset	234 ciKlass* get_unloaded_klass(ciKlass* accessing_klass,
0 a61af66fc99e Initial load duke parents: diff changeset	235 ciSymbol* name) {
a61af66fc99e Initial load duke parents: diff changeset	236 return _factory->get_unloaded_klass(accessing_klass, name, true);
a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	239 // Get a ciKlass representing an unloaded klass mirror.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	240 // Result is not necessarily unique, but will be unloaded.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	241 ciInstance* get_unloaded_klass_mirror(ciKlass* type) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	242 return _factory->get_unloaded_klass_mirror(type);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	243 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	244
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	245 // Get a ciInstance representing an unresolved method handle constant.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	246 ciInstance* get_unloaded_method_handle_constant(ciKlass* holder,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	247 ciSymbol* name,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	248 ciSymbol* signature,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	249 int ref_kind) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	250 return _factory->get_unloaded_method_handle_constant(holder, name, signature, ref_kind);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	251 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	252
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	253 // Get a ciInstance representing an unresolved method type constant.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	254 ciInstance* get_unloaded_method_type_constant(ciSymbol* signature) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	255 return _factory->get_unloaded_method_type_constant(signature);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	256 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	257
0 a61af66fc99e Initial load duke parents: diff changeset	258 // See if we already have an unloaded klass for the given name
a61af66fc99e Initial load duke parents: diff changeset	259 // or return NULL if not.
4001 5eb9169b1a14 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP twisti parents: 3899 diff changeset	260 ciKlass check_get_unloaded_klass(ciKlass accessing_klass, ciSymbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	261 return _factory->get_unloaded_klass(accessing_klass, name, false);
a61af66fc99e Initial load duke parents: diff changeset	262 }
a61af66fc99e Initial load duke parents: diff changeset	263
a61af66fc99e Initial load duke parents: diff changeset	264 // Get a ciReturnAddress corresponding to the given bci.
a61af66fc99e Initial load duke parents: diff changeset	265 // Ensures uniqueness of the result.
a61af66fc99e Initial load duke parents: diff changeset	266 ciReturnAddress* get_return_address(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	267 return _factory->get_return_address(bci);
a61af66fc99e Initial load duke parents: diff changeset	268 }
a61af66fc99e Initial load duke parents: diff changeset	269
a61af66fc99e Initial load duke parents: diff changeset	270 // Get a ciMethodData representing the methodData for a method
a61af66fc99e Initial load duke parents: diff changeset	271 // with none.
a61af66fc99e Initial load duke parents: diff changeset	272 ciMethodData* get_empty_methodData() {
a61af66fc99e Initial load duke parents: diff changeset	273 return _factory->get_empty_methodData();
a61af66fc99e Initial load duke parents: diff changeset	274 }
a61af66fc99e Initial load duke parents: diff changeset	275
a61af66fc99e Initial load duke parents: diff changeset	276 // General utility : get a buffer of some required length.
a61af66fc99e Initial load duke parents: diff changeset	277 // Used in symbol creation.
a61af66fc99e Initial load duke parents: diff changeset	278 char* name_buffer(int req_len);
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 // Is this thread currently in the VM state?
a61af66fc99e Initial load duke parents: diff changeset	281 static bool is_in_vm();
a61af66fc99e Initial load duke parents: diff changeset	282
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3785 diff changeset	283 // Helper routine for determining the validity of a compilation with
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3785 diff changeset	284 // respect to method dependencies (e.g. concurrent class loading).
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3785 diff changeset	285 void validate_compile_task_dependencies(ciMethod* target);
0 a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 public:
a61af66fc99e Initial load duke parents: diff changeset	288 enum {
a61af66fc99e Initial load duke parents: diff changeset	289 MethodCompilable,
a61af66fc99e Initial load duke parents: diff changeset	290 MethodCompilable_not_at_tier,
a61af66fc99e Initial load duke parents: diff changeset	291 MethodCompilable_never
a61af66fc99e Initial load duke parents: diff changeset	292 };
a61af66fc99e Initial load duke parents: diff changeset	293
a61af66fc99e Initial load duke parents: diff changeset	294 ciEnv(CompileTask* task, int system_dictionary_modification_counter);
a61af66fc99e Initial load duke parents: diff changeset	295 // Used only during initialization of the ci
a61af66fc99e Initial load duke parents: diff changeset	296 ciEnv(Arena* arena);
a61af66fc99e Initial load duke parents: diff changeset	297 ~ciEnv();
a61af66fc99e Initial load duke parents: diff changeset	298
a61af66fc99e Initial load duke parents: diff changeset	299 OopRecorder* oop_recorder() { return _oop_recorder; }
a61af66fc99e Initial load duke parents: diff changeset	300 void set_oop_recorder(OopRecorder* r) { _oop_recorder = r; }
a61af66fc99e Initial load duke parents: diff changeset	301
a61af66fc99e Initial load duke parents: diff changeset	302 DebugInformationRecorder* debug_info() { return _debug_info; }
a61af66fc99e Initial load duke parents: diff changeset	303 void set_debug_info(DebugInformationRecorder* i) { _debug_info = i; }
a61af66fc99e Initial load duke parents: diff changeset	304
a61af66fc99e Initial load duke parents: diff changeset	305 Dependencies* dependencies() { return _dependencies; }
a61af66fc99e Initial load duke parents: diff changeset	306 void set_dependencies(Dependencies* d) { _dependencies = d; }
a61af66fc99e Initial load duke parents: diff changeset	307
a61af66fc99e Initial load duke parents: diff changeset	308 // This is true if the compilation is not going to produce code.
a61af66fc99e Initial load duke parents: diff changeset	309 // (It is reasonable to retry failed compilations.)
a61af66fc99e Initial load duke parents: diff changeset	310 bool failing() { return _failure_reason != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	311
a61af66fc99e Initial load duke parents: diff changeset	312 // Reason this compilation is failing, such as "too many basic blocks".
a61af66fc99e Initial load duke parents: diff changeset	313 const char* failure_reason() { return _failure_reason; }
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 // Return state of appropriate compilability
a61af66fc99e Initial load duke parents: diff changeset	316 int compilable() { return _compilable; }
a61af66fc99e Initial load duke parents: diff changeset	317
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	318 const char* retry_message() const {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	319 switch (_compilable) {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	320 case ciEnv::MethodCompilable_not_at_tier:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	321 return "retry at different tier";
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	322 case ciEnv::MethodCompilable_never:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	323 return "not retryable";
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	324 case ciEnv::MethodCompilable:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	325 return NULL;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	326 default:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	327 ShouldNotReachHere();
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	328 return NULL;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	329 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	330 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	331
0 a61af66fc99e Initial load duke parents: diff changeset	332 bool break_at_compile() { return _break_at_compile; }
a61af66fc99e Initial load duke parents: diff changeset	333 void set_break_at_compile(bool z) { _break_at_compile = z; }
a61af66fc99e Initial load duke parents: diff changeset	334
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	335 // Cache Jvmti state
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	336 void cache_jvmti_state();
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	337 bool jvmti_can_hotswap_or_post_breakpoint() const { return _jvmti_can_hotswap_or_post_breakpoint; }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	338 bool jvmti_can_access_local_variables() const { return _jvmti_can_access_local_variables; }
1213 6deeaebad47a 6902182: 4/4 Starting with jdwp agent should not incur performance penalty dcubed parents: 1142 diff changeset	339 bool jvmti_can_post_on_exceptions() const { return _jvmti_can_post_on_exceptions; }
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	340
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	341 // Cache DTrace flags
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	342 void cache_dtrace_flags();
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	343 bool dtrace_extended_probes() const { return _dtrace_extended_probes; }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	344 bool dtrace_monitor_probes() const { return _dtrace_monitor_probes; }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	345 bool dtrace_method_probes() const { return _dtrace_method_probes; }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	346 bool dtrace_alloc_probes() const { return _dtrace_alloc_probes; }
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	347
0 a61af66fc99e Initial load duke parents: diff changeset	348 // The compiler task which has created this env.
a61af66fc99e Initial load duke parents: diff changeset	349 // May be useful to find out compile_id, comp_level, etc.
a61af66fc99e Initial load duke parents: diff changeset	350 CompileTask* task() { return _task; }
a61af66fc99e Initial load duke parents: diff changeset	351 // Handy forwards to the task:
a61af66fc99e Initial load duke parents: diff changeset	352 int comp_level(); // task()->comp_level()
a61af66fc99e Initial load duke parents: diff changeset	353 uint compile_id(); // task()->compile_id()
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 // Register the result of a compilation.
a61af66fc99e Initial load duke parents: diff changeset	356 void register_method(ciMethod* target,
a61af66fc99e Initial load duke parents: diff changeset	357 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	358 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	359 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	360 CodeBuffer* code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	361 int frame_words,
a61af66fc99e Initial load duke parents: diff changeset	362 OopMapSet* oop_map_set,
a61af66fc99e Initial load duke parents: diff changeset	363 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	364 ImplicitExceptionTable* inc_table,
a61af66fc99e Initial load duke parents: diff changeset	365 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	366 int comp_level,
6792 137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	367 bool has_unsafe_access,
137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	368 bool has_wide_vectors);
0 a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370
a61af66fc99e Initial load duke parents: diff changeset	371 // Access to certain well known ciObjects.
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	372 #define WK_KLASS_FUNC(name, ignore_s, ignore_o) \
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	373 ciInstanceKlass* name() { \
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	374 return _##name;\
0 a61af66fc99e Initial load duke parents: diff changeset	375 }
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	376 WK_KLASSES_DO(WK_KLASS_FUNC)
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	377 #undef WK_KLASS_FUNC
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	378
0 a61af66fc99e Initial load duke parents: diff changeset	379 ciInstance* NullPointerException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	380 assert(_NullPointerException_instance != NULL, "initialization problem");
a61af66fc99e Initial load duke parents: diff changeset	381 return _NullPointerException_instance;
a61af66fc99e Initial load duke parents: diff changeset	382 }
a61af66fc99e Initial load duke parents: diff changeset	383 ciInstance* ArithmeticException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	384 assert(_ArithmeticException_instance != NULL, "initialization problem");
a61af66fc99e Initial load duke parents: diff changeset	385 return _ArithmeticException_instance;
a61af66fc99e Initial load duke parents: diff changeset	386 }
a61af66fc99e Initial load duke parents: diff changeset	387
a61af66fc99e Initial load duke parents: diff changeset	388 // Lazy constructors:
a61af66fc99e Initial load duke parents: diff changeset	389 ciInstance* ArrayIndexOutOfBoundsException_instance();
a61af66fc99e Initial load duke parents: diff changeset	390 ciInstance* ArrayStoreException_instance();
a61af66fc99e Initial load duke parents: diff changeset	391 ciInstance* ClassCastException_instance();
a61af66fc99e Initial load duke parents: diff changeset	392
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	393 ciInstance* the_null_string();
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	394 ciInstance* the_min_jint_string();
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	395
0 a61af66fc99e Initial load duke parents: diff changeset	396 static ciSymbol* unloaded_cisymbol() {
a61af66fc99e Initial load duke parents: diff changeset	397 return _unloaded_cisymbol;
a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399 static ciObjArrayKlass* unloaded_ciobjarrayklass() {
a61af66fc99e Initial load duke parents: diff changeset	400 return _unloaded_ciobjarrayklass;
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402 static ciInstanceKlass* unloaded_ciinstance_klass() {
a61af66fc99e Initial load duke parents: diff changeset	403 return _unloaded_ciinstance_klass;
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405
a61af66fc99e Initial load duke parents: diff changeset	406 ciKlass* find_system_klass(ciSymbol* klass_name);
a61af66fc99e Initial load duke parents: diff changeset	407 // Note: To find a class from its name string, use ciSymbol::make,
a61af66fc99e Initial load duke parents: diff changeset	408 // but consider adding to vmSymbols.hpp instead.
a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 // converts the ciKlass* representing the holder of a method into a
a61af66fc99e Initial load duke parents: diff changeset	411 // ciInstanceKlass*. This is needed since the holder of a method in
a61af66fc99e Initial load duke parents: diff changeset	412 // the bytecodes could be an array type. Basically this converts
a61af66fc99e Initial load duke parents: diff changeset	413 // array types into java/lang/Object and other types stay as they are.
a61af66fc99e Initial load duke parents: diff changeset	414 static ciInstanceKlass* get_instance_klass_for_declared_method_holder(ciKlass* klass);
a61af66fc99e Initial load duke parents: diff changeset	415
a61af66fc99e Initial load duke parents: diff changeset	416 // Return the machine-level offset of o, which must be an element of a.
a61af66fc99e Initial load duke parents: diff changeset	417 // This may be used to form constant-loading expressions in lieu of simpler encodings.
a61af66fc99e Initial load duke parents: diff changeset	418 int array_element_offset_in_bytes(ciArray* a, ciObject* o);
a61af66fc99e Initial load duke parents: diff changeset	419
a61af66fc99e Initial load duke parents: diff changeset	420 // Access to the compile-lifetime allocation arena.
a61af66fc99e Initial load duke parents: diff changeset	421 Arena* arena() { return _arena; }
a61af66fc99e Initial load duke parents: diff changeset	422
a61af66fc99e Initial load duke parents: diff changeset	423 // What is the current compilation environment?
a61af66fc99e Initial load duke parents: diff changeset	424 static ciEnv* current() { return CompilerThread::current()->env(); }
a61af66fc99e Initial load duke parents: diff changeset	425
a61af66fc99e Initial load duke parents: diff changeset	426 // Overload with current thread argument
a61af66fc99e Initial load duke parents: diff changeset	427 static ciEnv* current(CompilerThread *thread) { return thread->env(); }
a61af66fc99e Initial load duke parents: diff changeset	428
a61af66fc99e Initial load duke parents: diff changeset	429 // Per-compiler data. (Used by C2 to publish the Compile* pointer.)
a61af66fc99e Initial load duke parents: diff changeset	430 void* compiler_data() { return _compiler_data; }
a61af66fc99e Initial load duke parents: diff changeset	431 void set_compiler_data(void* x) { _compiler_data = x; }
a61af66fc99e Initial load duke parents: diff changeset	432
a61af66fc99e Initial load duke parents: diff changeset	433 // Notice that a method has been inlined in the current compile;
a61af66fc99e Initial load duke parents: diff changeset	434 // used only for statistics.
a61af66fc99e Initial load duke parents: diff changeset	435 void notice_inlined_method(ciMethod* method);
a61af66fc99e Initial load duke parents: diff changeset	436
a61af66fc99e Initial load duke parents: diff changeset	437 // Total number of bytecodes in inlined methods in this compile
a61af66fc99e Initial load duke parents: diff changeset	438 int num_inlined_bytecodes() const;
a61af66fc99e Initial load duke parents: diff changeset	439
a61af66fc99e Initial load duke parents: diff changeset	440 // Output stream for logging compilation info.
a61af66fc99e Initial load duke parents: diff changeset	441 CompileLog* log() { return _log; }
a61af66fc99e Initial load duke parents: diff changeset	442 void set_log(CompileLog* log) { _log = log; }
a61af66fc99e Initial load duke parents: diff changeset	443
a61af66fc99e Initial load duke parents: diff changeset	444 // Check for changes to the system dictionary during compilation
a61af66fc99e Initial load duke parents: diff changeset	445 bool system_dictionary_modification_counter_changed();
a61af66fc99e Initial load duke parents: diff changeset	446
a61af66fc99e Initial load duke parents: diff changeset	447 void record_failure(const char* reason);
a61af66fc99e Initial load duke parents: diff changeset	448 void record_method_not_compilable(const char* reason, bool all_tiers = true);
a61af66fc99e Initial load duke parents: diff changeset	449 void record_out_of_memory_failure();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	450
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	451 // RedefineClasses support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	452 void metadata_do(void f(Metadata*)) { _factory->metadata_do(f); }
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	453
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	454 // Dump the compilation replay data for this ciEnv to
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	455 // ReplayDataFile, creating the file if needed.
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	456 void dump_replay_data();
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	457
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	458 // Dump the compilation replay data for the ciEnv to the stream.
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	459 void dump_replay_data(outputStream* out);
0 a61af66fc99e Initial load duke parents: diff changeset	460 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	461
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	462 #endif // SHARE_VM_CI_CIENV_HPP

Mercurial > hg > truffle

annotate src/share/vm/ci/ciEnv.hpp @ 6972:bd7a7ce2e264