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

annotate src/share/vm/ci/ciEnv.hpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	2c6ef90f030a
children	7848fc12602b

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17467 55fb97c4c58d 8029233: Update copyright year to match last edit in jdk8 hotspot repository for 2013 mikael parents: 12865 diff changeset	2 * Copyright (c) 1999, 2013, 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,
3785 ddd894528dbc 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
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17780 diff changeset	187 void ensure_metadata_alive(ciMetadata* m) {
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17780 diff changeset	188 _factory->ensure_metadata_alive(m);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17780 diff changeset	189 }
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 17780 diff changeset	190
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	191 ciInstance* get_instance(oop 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_object(o)->as_instance();
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 ciObjArrayKlass* get_obj_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_obj_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 ciTypeArrayKlass* get_type_array_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_type_array_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 ciKlass* get_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_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 ciInstanceKlass* get_instance_klass(Klass* 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_instance_klass();
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 ciMethod* get_method(Method* 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();
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 ciMethodData* get_method_data(MethodData* o) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	216 if (o == NULL) return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	217 return get_metadata(o)->as_method_data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	218 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	219
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	220 ciMethod* get_method_from_handle(Method* method);
0 a61af66fc99e Initial load duke parents: diff changeset	221
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	222 ciInstance* get_or_create_exception(jobject& handle, Symbol* name);
0 a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 // Get a ciMethod representing either an unfound method or
a61af66fc99e Initial load duke parents: diff changeset	225 // a method with an unloaded holder. Ensures uniqueness of
a61af66fc99e Initial load duke parents: diff changeset	226 // the result.
a61af66fc99e Initial load duke parents: diff changeset	227 ciMethod* get_unloaded_method(ciInstanceKlass* holder,
a61af66fc99e Initial load duke parents: diff changeset	228 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	229 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	230 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	231 return _factory->get_unloaded_method(holder, name, signature, accessor);
0 a61af66fc99e Initial load duke parents: diff changeset	232 }
a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 // Get a ciKlass representing an unloaded klass.
a61af66fc99e Initial load duke parents: diff changeset	235 // 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	236 ciKlass* get_unloaded_klass(ciKlass* accessing_klass,
0 a61af66fc99e Initial load duke parents: diff changeset	237 ciSymbol* name) {
a61af66fc99e Initial load duke parents: diff changeset	238 return _factory->get_unloaded_klass(accessing_klass, name, true);
a61af66fc99e Initial load duke parents: diff changeset	239 }
a61af66fc99e Initial load duke parents: diff changeset	240
1602 136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	241 // Get a ciKlass representing an unloaded klass mirror.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	242 // Result is not necessarily unique, but will be unloaded.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	243 ciInstance* get_unloaded_klass_mirror(ciKlass* type) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	244 return _factory->get_unloaded_klass_mirror(type);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	245 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	246
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	247 // Get a ciInstance representing an unresolved method handle constant.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	248 ciInstance* get_unloaded_method_handle_constant(ciKlass* holder,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	249 ciSymbol* name,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	250 ciSymbol* signature,
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	251 int ref_kind) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	252 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	253 }
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 // Get a ciInstance representing an unresolved method type constant.
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	256 ciInstance* get_unloaded_method_type_constant(ciSymbol* signature) {
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	257 return _factory->get_unloaded_method_type_constant(signature);
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	258 }
136b78722a08 6939203: JSR 292 needs method handle constants jrose parents: 1552 diff changeset	259
0 a61af66fc99e Initial load duke parents: diff changeset	260 // See if we already have an unloaded klass for the given name
a61af66fc99e Initial load duke parents: diff changeset	261 // 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	262 ciKlass check_get_unloaded_klass(ciKlass accessing_klass, ciSymbol* name) {
0 a61af66fc99e Initial load duke parents: diff changeset	263 return _factory->get_unloaded_klass(accessing_klass, name, false);
a61af66fc99e Initial load duke parents: diff changeset	264 }
a61af66fc99e Initial load duke parents: diff changeset	265
a61af66fc99e Initial load duke parents: diff changeset	266 // Get a ciReturnAddress corresponding to the given bci.
a61af66fc99e Initial load duke parents: diff changeset	267 // Ensures uniqueness of the result.
a61af66fc99e Initial load duke parents: diff changeset	268 ciReturnAddress* get_return_address(int bci) {
a61af66fc99e Initial load duke parents: diff changeset	269 return _factory->get_return_address(bci);
a61af66fc99e Initial load duke parents: diff changeset	270 }
a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 // Get a ciMethodData representing the methodData for a method
a61af66fc99e Initial load duke parents: diff changeset	273 // with none.
a61af66fc99e Initial load duke parents: diff changeset	274 ciMethodData* get_empty_methodData() {
a61af66fc99e Initial load duke parents: diff changeset	275 return _factory->get_empty_methodData();
a61af66fc99e Initial load duke parents: diff changeset	276 }
a61af66fc99e Initial load duke parents: diff changeset	277
a61af66fc99e Initial load duke parents: diff changeset	278 // General utility : get a buffer of some required length.
a61af66fc99e Initial load duke parents: diff changeset	279 // Used in symbol creation.
a61af66fc99e Initial load duke parents: diff changeset	280 char* name_buffer(int req_len);
a61af66fc99e Initial load duke parents: diff changeset	281
a61af66fc99e Initial load duke parents: diff changeset	282 // Is this thread currently in the VM state?
a61af66fc99e Initial load duke parents: diff changeset	283 static bool is_in_vm();
a61af66fc99e Initial load duke parents: diff changeset	284
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3785 diff changeset	285 // 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	286 // 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	287 void validate_compile_task_dependencies(ciMethod* target);
0 a61af66fc99e Initial load duke parents: diff changeset	288
a61af66fc99e Initial load duke parents: diff changeset	289 public:
a61af66fc99e Initial load duke parents: diff changeset	290 enum {
a61af66fc99e Initial load duke parents: diff changeset	291 MethodCompilable,
a61af66fc99e Initial load duke parents: diff changeset	292 MethodCompilable_not_at_tier,
a61af66fc99e Initial load duke parents: diff changeset	293 MethodCompilable_never
a61af66fc99e Initial load duke parents: diff changeset	294 };
a61af66fc99e Initial load duke parents: diff changeset	295
a61af66fc99e Initial load duke parents: diff changeset	296 ciEnv(CompileTask* task, int system_dictionary_modification_counter);
a61af66fc99e Initial load duke parents: diff changeset	297 // Used only during initialization of the ci
a61af66fc99e Initial load duke parents: diff changeset	298 ciEnv(Arena* arena);
a61af66fc99e Initial load duke parents: diff changeset	299 ~ciEnv();
a61af66fc99e Initial load duke parents: diff changeset	300
a61af66fc99e Initial load duke parents: diff changeset	301 OopRecorder* oop_recorder() { return _oop_recorder; }
a61af66fc99e Initial load duke parents: diff changeset	302 void set_oop_recorder(OopRecorder* r) { _oop_recorder = r; }
a61af66fc99e Initial load duke parents: diff changeset	303
a61af66fc99e Initial load duke parents: diff changeset	304 DebugInformationRecorder* debug_info() { return _debug_info; }
a61af66fc99e Initial load duke parents: diff changeset	305 void set_debug_info(DebugInformationRecorder* i) { _debug_info = i; }
a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 Dependencies* dependencies() { return _dependencies; }
a61af66fc99e Initial load duke parents: diff changeset	308 void set_dependencies(Dependencies* d) { _dependencies = d; }
a61af66fc99e Initial load duke parents: diff changeset	309
a61af66fc99e Initial load duke parents: diff changeset	310 // This is true if the compilation is not going to produce code.
a61af66fc99e Initial load duke parents: diff changeset	311 // (It is reasonable to retry failed compilations.)
a61af66fc99e Initial load duke parents: diff changeset	312 bool failing() { return _failure_reason != NULL; }
a61af66fc99e Initial load duke parents: diff changeset	313
a61af66fc99e Initial load duke parents: diff changeset	314 // Reason this compilation is failing, such as "too many basic blocks".
a61af66fc99e Initial load duke parents: diff changeset	315 const char* failure_reason() { return _failure_reason; }
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 // Return state of appropriate compilability
a61af66fc99e Initial load duke parents: diff changeset	318 int compilable() { return _compilable; }
a61af66fc99e Initial load duke parents: diff changeset	319
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	320 const char* retry_message() const {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	321 switch (_compilable) {
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	322 case ciEnv::MethodCompilable_not_at_tier:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	323 return "retry at different tier";
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	324 case ciEnv::MethodCompilable_never:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	325 return "not retryable";
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	326 case ciEnv::MethodCompilable:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	327 return NULL;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	328 default:
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	329 ShouldNotReachHere();
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	330 return NULL;
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	331 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	332 }
aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 4001 diff changeset	333
0 a61af66fc99e Initial load duke parents: diff changeset	334 bool break_at_compile() { return _break_at_compile; }
a61af66fc99e Initial load duke parents: diff changeset	335 void set_break_at_compile(bool z) { _break_at_compile = z; }
a61af66fc99e Initial load duke parents: diff changeset	336
780 c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	337 // 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	338 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	339 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	340 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	341 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	342
c96bf21b756f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits kvn parents: 0 diff changeset	343 // 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	344 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	345 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	346 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	347 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	348 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	349
0 a61af66fc99e Initial load duke parents: diff changeset	350 // The compiler task which has created this env.
a61af66fc99e Initial load duke parents: diff changeset	351 // May be useful to find out compile_id, comp_level, etc.
a61af66fc99e Initial load duke parents: diff changeset	352 CompileTask* task() { return _task; }
a61af66fc99e Initial load duke parents: diff changeset	353 // Handy forwards to the task:
a61af66fc99e Initial load duke parents: diff changeset	354 int comp_level(); // task()->comp_level()
a61af66fc99e Initial load duke parents: diff changeset	355 uint compile_id(); // task()->compile_id()
a61af66fc99e Initial load duke parents: diff changeset	356
a61af66fc99e Initial load duke parents: diff changeset	357 // Register the result of a compilation.
a61af66fc99e Initial load duke parents: diff changeset	358 void register_method(ciMethod* target,
a61af66fc99e Initial load duke parents: diff changeset	359 int entry_bci,
a61af66fc99e Initial load duke parents: diff changeset	360 CodeOffsets* offsets,
a61af66fc99e Initial load duke parents: diff changeset	361 int orig_pc_offset,
a61af66fc99e Initial load duke parents: diff changeset	362 CodeBuffer* code_buffer,
a61af66fc99e Initial load duke parents: diff changeset	363 int frame_words,
a61af66fc99e Initial load duke parents: diff changeset	364 OopMapSet* oop_map_set,
a61af66fc99e Initial load duke parents: diff changeset	365 ExceptionHandlerTable* handler_table,
a61af66fc99e Initial load duke parents: diff changeset	366 ImplicitExceptionTable* inc_table,
a61af66fc99e Initial load duke parents: diff changeset	367 AbstractCompiler* compiler,
a61af66fc99e Initial load duke parents: diff changeset	368 int comp_level,
6792 137868b7aa6f 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect kvn parents: 6725 diff changeset	369 bool has_unsafe_access,
17780 606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 17622 diff changeset	370 bool has_wide_vectors,
606acabe7b5c 8031320: Use Intel RTM instructions for locks kvn parents: 17622 diff changeset	371 RTMState rtm_state = NoRTM);
0 a61af66fc99e Initial load duke parents: diff changeset	372
a61af66fc99e Initial load duke parents: diff changeset	373
a61af66fc99e Initial load duke parents: diff changeset	374 // Access to certain well known ciObjects.
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	375 #define WK_KLASS_FUNC(name, ignore_s, ignore_o) \
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	376 ciInstanceKlass* name() { \
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	377 return _##name;\
0 a61af66fc99e Initial load duke parents: diff changeset	378 }
1142 4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	379 WK_KLASSES_DO(WK_KLASS_FUNC)
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	380 #undef WK_KLASS_FUNC
4ce7240d622c 6914300: ciEnv should export all well known classes never parents: 1138 diff changeset	381
0 a61af66fc99e Initial load duke parents: diff changeset	382 ciInstance* NullPointerException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	383 assert(_NullPointerException_instance != NULL, "initialization problem");
a61af66fc99e Initial load duke parents: diff changeset	384 return _NullPointerException_instance;
a61af66fc99e Initial load duke parents: diff changeset	385 }
a61af66fc99e Initial load duke parents: diff changeset	386 ciInstance* ArithmeticException_instance() {
a61af66fc99e Initial load duke parents: diff changeset	387 assert(_ArithmeticException_instance != NULL, "initialization problem");
a61af66fc99e Initial load duke parents: diff changeset	388 return _ArithmeticException_instance;
a61af66fc99e Initial load duke parents: diff changeset	389 }
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 // Lazy constructors:
a61af66fc99e Initial load duke parents: diff changeset	392 ciInstance* ArrayIndexOutOfBoundsException_instance();
a61af66fc99e Initial load duke parents: diff changeset	393 ciInstance* ArrayStoreException_instance();
a61af66fc99e Initial load duke parents: diff changeset	394 ciInstance* ClassCastException_instance();
a61af66fc99e Initial load duke parents: diff changeset	395
1080 7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	396 ciInstance* the_null_string();
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	397 ciInstance* the_min_jint_string();
7c57aead6d3e 6892658: C2 should optimize some stringbuilder patterns never parents: 989 diff changeset	398
0 a61af66fc99e Initial load duke parents: diff changeset	399 static ciSymbol* unloaded_cisymbol() {
a61af66fc99e Initial load duke parents: diff changeset	400 return _unloaded_cisymbol;
a61af66fc99e Initial load duke parents: diff changeset	401 }
a61af66fc99e Initial load duke parents: diff changeset	402 static ciObjArrayKlass* unloaded_ciobjarrayklass() {
a61af66fc99e Initial load duke parents: diff changeset	403 return _unloaded_ciobjarrayklass;
a61af66fc99e Initial load duke parents: diff changeset	404 }
a61af66fc99e Initial load duke parents: diff changeset	405 static ciInstanceKlass* unloaded_ciinstance_klass() {
a61af66fc99e Initial load duke parents: diff changeset	406 return _unloaded_ciinstance_klass;
a61af66fc99e Initial load duke parents: diff changeset	407 }
12160 f98f5d48f511 7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked roland parents: 10195 diff changeset	408 ciInstance* unloaded_ciinstance();
0 a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 ciKlass* find_system_klass(ciSymbol* klass_name);
a61af66fc99e Initial load duke parents: diff changeset	411 // Note: To find a class from its name string, use ciSymbol::make,
a61af66fc99e Initial load duke parents: diff changeset	412 // but consider adding to vmSymbols.hpp instead.
a61af66fc99e Initial load duke parents: diff changeset	413
a61af66fc99e Initial load duke parents: diff changeset	414 // converts the ciKlass* representing the holder of a method into a
a61af66fc99e Initial load duke parents: diff changeset	415 // ciInstanceKlass*. This is needed since the holder of a method in
a61af66fc99e Initial load duke parents: diff changeset	416 // the bytecodes could be an array type. Basically this converts
a61af66fc99e Initial load duke parents: diff changeset	417 // array types into java/lang/Object and other types stay as they are.
a61af66fc99e Initial load duke parents: diff changeset	418 static ciInstanceKlass* get_instance_klass_for_declared_method_holder(ciKlass* klass);
a61af66fc99e Initial load duke parents: diff changeset	419
a61af66fc99e Initial load duke parents: diff changeset	420 // Return the machine-level offset of o, which must be an element of a.
a61af66fc99e Initial load duke parents: diff changeset	421 // This may be used to form constant-loading expressions in lieu of simpler encodings.
a61af66fc99e Initial load duke parents: diff changeset	422 int array_element_offset_in_bytes(ciArray* a, ciObject* o);
a61af66fc99e Initial load duke parents: diff changeset	423
a61af66fc99e Initial load duke parents: diff changeset	424 // Access to the compile-lifetime allocation arena.
a61af66fc99e Initial load duke parents: diff changeset	425 Arena* arena() { return _arena; }
a61af66fc99e Initial load duke parents: diff changeset	426
a61af66fc99e Initial load duke parents: diff changeset	427 // What is the current compilation environment?
a61af66fc99e Initial load duke parents: diff changeset	428 static ciEnv* current() { return CompilerThread::current()->env(); }
a61af66fc99e Initial load duke parents: diff changeset	429
a61af66fc99e Initial load duke parents: diff changeset	430 // Overload with current thread argument
a61af66fc99e Initial load duke parents: diff changeset	431 static ciEnv* current(CompilerThread *thread) { return thread->env(); }
a61af66fc99e Initial load duke parents: diff changeset	432
a61af66fc99e Initial load duke parents: diff changeset	433 // Per-compiler data. (Used by C2 to publish the Compile* pointer.)
a61af66fc99e Initial load duke parents: diff changeset	434 void* compiler_data() { return _compiler_data; }
a61af66fc99e Initial load duke parents: diff changeset	435 void set_compiler_data(void* x) { _compiler_data = x; }
a61af66fc99e Initial load duke parents: diff changeset	436
a61af66fc99e Initial load duke parents: diff changeset	437 // Notice that a method has been inlined in the current compile;
a61af66fc99e Initial load duke parents: diff changeset	438 // used only for statistics.
a61af66fc99e Initial load duke parents: diff changeset	439 void notice_inlined_method(ciMethod* method);
a61af66fc99e Initial load duke parents: diff changeset	440
a61af66fc99e Initial load duke parents: diff changeset	441 // Total number of bytecodes in inlined methods in this compile
a61af66fc99e Initial load duke parents: diff changeset	442 int num_inlined_bytecodes() const;
a61af66fc99e Initial load duke parents: diff changeset	443
a61af66fc99e Initial load duke parents: diff changeset	444 // Output stream for logging compilation info.
a61af66fc99e Initial load duke parents: diff changeset	445 CompileLog* log() { return _log; }
a61af66fc99e Initial load duke parents: diff changeset	446 void set_log(CompileLog* log) { _log = log; }
a61af66fc99e Initial load duke parents: diff changeset	447
a61af66fc99e Initial load duke parents: diff changeset	448 // Check for changes to the system dictionary during compilation
a61af66fc99e Initial load duke parents: diff changeset	449 bool system_dictionary_modification_counter_changed();
a61af66fc99e Initial load duke parents: diff changeset	450
a61af66fc99e Initial load duke parents: diff changeset	451 void record_failure(const char* reason);
a61af66fc99e Initial load duke parents: diff changeset	452 void record_method_not_compilable(const char* reason, bool all_tiers = true);
a61af66fc99e Initial load duke parents: diff changeset	453 void record_out_of_memory_failure();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	454
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	455 // RedefineClasses support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6634 diff changeset	456 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	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.
17622 849eb7bfceac 8028468: Add inlining information into ciReplay kvn parents: 17467 diff changeset	459 void dump_replay_data(int compile_id);
849eb7bfceac 8028468: Add inlining information into ciReplay kvn parents: 17467 diff changeset	460 void dump_inline_data(int compile_id);
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6792 diff changeset	461 void dump_replay_data(outputStream* out);
12865 5cc2d82aa82a 8024943: ciReplay: fails to dump replay data during safepointing vlivanov parents: 12160 diff changeset	462 void dump_replay_data_unsafe(outputStream* out);
17622 849eb7bfceac 8028468: Add inlining information into ciReplay kvn parents: 17467 diff changeset	463 void dump_compile_data(outputStream* out);
0 a61af66fc99e Initial load duke parents: diff changeset	464 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	465
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1602 diff changeset	466 #endif // SHARE_VM_CI_CIENV_HPP

Mercurial > hg > truffle

annotate src/share/vm/ci/ciEnv.hpp @ 20543:e7d0505c8a30