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

annotate src/share/vm/ci/ciEnv.hpp @ 13212:eb03a7335eb0

Use fixed instead of virtual register for target in far foreign call, since the register allocator does not support virtual registers to be used at call sites.

author	Christian Wimmer <christian.wimmer@oracle.com>
date	Mon, 02 Dec 2013 14:20:32 -0800
parents	096c224171c4
children	d8041d695d19

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

Mercurial > hg > truffle

annotate src/share/vm/ci/ciEnv.hpp @ 13212:eb03a7335eb0