graal-compiler: src/share/vm/code/dependencies.hpp annotate

annotate src/share/vm/code/dependencies.hpp @ 3992:d1bdeef3e3e2

7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76 Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing. Reviewed-by: tonyp, brutisso, ysr

author	johnc
date	Wed, 12 Oct 2011 10:25:51 -0700
parents	b27c72d69fd1
children	da91efe96a93

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	2 * Copyright (c) 2005, 2011, 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: 1123 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1123 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: 1123 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: 1552 diff changeset	25 #ifndef SHARE_VM_CODE_DEPENDENCIES_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	26 #define SHARE_VM_CODE_DEPENDENCIES_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	27
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	28 #include "ci/ciCallSite.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	29 #include "ci/ciKlass.hpp"
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	30 #include "ci/ciMethodHandle.hpp"
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	31 #include "classfile/systemDictionary.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	32 #include "code/compressedStream.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	33 #include "code/nmethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	34 #include "utilities/growableArray.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	35
0 a61af66fc99e Initial load duke parents: diff changeset	36 //** Dependencies represent assertions (approximate invariants) within
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	37 // the runtime system, e.g. class hierarchy changes. An example is an
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	38 // assertion that a given method is not overridden; another example is
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	39 // that a type has only one concrete subtype. Compiled code which
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	40 // relies on such assertions must be discarded if they are overturned
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	41 // by changes in the runtime system. We can think of these assertions
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	42 // as approximate invariants, because we expect them to be overturned
0 a61af66fc99e Initial load duke parents: diff changeset	43 // very infrequently. We are willing to perform expensive recovery
a61af66fc99e Initial load duke parents: diff changeset	44 // operations when they are overturned. The benefit, of course, is
a61af66fc99e Initial load duke parents: diff changeset	45 // performing optimistic optimizations (!) on the object code.
a61af66fc99e Initial load duke parents: diff changeset	46 //
a61af66fc99e Initial load duke parents: diff changeset	47 // Changes in the class hierarchy due to dynamic linking or
a61af66fc99e Initial load duke parents: diff changeset	48 // class evolution can violate dependencies. There is enough
a61af66fc99e Initial load duke parents: diff changeset	49 // indexing between classes and nmethods to make dependency
a61af66fc99e Initial load duke parents: diff changeset	50 // checking reasonably efficient.
a61af66fc99e Initial load duke parents: diff changeset	51
a61af66fc99e Initial load duke parents: diff changeset	52 class ciEnv;
a61af66fc99e Initial load duke parents: diff changeset	53 class nmethod;
a61af66fc99e Initial load duke parents: diff changeset	54 class OopRecorder;
a61af66fc99e Initial load duke parents: diff changeset	55 class xmlStream;
a61af66fc99e Initial load duke parents: diff changeset	56 class CompileLog;
a61af66fc99e Initial load duke parents: diff changeset	57 class DepChange;
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	58 class KlassDepChange;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	59 class CallSiteDepChange;
0 a61af66fc99e Initial load duke parents: diff changeset	60 class No_Safepoint_Verifier;
a61af66fc99e Initial load duke parents: diff changeset	61
a61af66fc99e Initial load duke parents: diff changeset	62 class Dependencies: public ResourceObj {
a61af66fc99e Initial load duke parents: diff changeset	63 public:
a61af66fc99e Initial load duke parents: diff changeset	64 // Note: In the comments on dependency types, most uses of the terms
a61af66fc99e Initial load duke parents: diff changeset	65 // subtype and supertype are used in a "non-strict" or "inclusive"
a61af66fc99e Initial load duke parents: diff changeset	66 // sense, and are starred to remind the reader of this fact.
a61af66fc99e Initial load duke parents: diff changeset	67 // Strict uses of the terms use the word "proper".
a61af66fc99e Initial load duke parents: diff changeset	68 //
a61af66fc99e Initial load duke parents: diff changeset	69 // Specifically, every class is its own subtype* and supertype*.
a61af66fc99e Initial load duke parents: diff changeset	70 // (This trick is easier than continually saying things like "Y is a
a61af66fc99e Initial load duke parents: diff changeset	71 // subtype of X or X itself".)
a61af66fc99e Initial load duke parents: diff changeset	72 //
a61af66fc99e Initial load duke parents: diff changeset	73 // Sometimes we write X > Y to mean X is a proper supertype of Y.
a61af66fc99e Initial load duke parents: diff changeset	74 // The notation X > {Y, Z} means X has proper subtypes Y, Z.
a61af66fc99e Initial load duke parents: diff changeset	75 // The notation X.m > Y means that Y inherits m from X, while
a61af66fc99e Initial load duke parents: diff changeset	76 // X.m > Y.m means Y overrides X.m. A star denotes abstractness,
a61af66fc99e Initial load duke parents: diff changeset	77 // as *I > A, meaning (abstract) interface I is a super type of A,
a61af66fc99e Initial load duke parents: diff changeset	78 // or A.*m > B.m, meaning B.m implements abstract method A.m.
a61af66fc99e Initial load duke parents: diff changeset	79 //
a61af66fc99e Initial load duke parents: diff changeset	80 // In this module, the terms "subtype" and "supertype" refer to
a61af66fc99e Initial load duke parents: diff changeset	81 // Java-level reference type conversions, as detected by
a61af66fc99e Initial load duke parents: diff changeset	82 // "instanceof" and performed by "checkcast" operations. The method
a61af66fc99e Initial load duke parents: diff changeset	83 // Klass::is_subtype_of tests these relations. Note that "subtype"
a61af66fc99e Initial load duke parents: diff changeset	84 // is richer than "subclass" (as tested by Klass::is_subclass_of),
a61af66fc99e Initial load duke parents: diff changeset	85 // since it takes account of relations involving interface and array
a61af66fc99e Initial load duke parents: diff changeset	86 // types.
a61af66fc99e Initial load duke parents: diff changeset	87 //
a61af66fc99e Initial load duke parents: diff changeset	88 // To avoid needless complexity, dependencies involving array types
a61af66fc99e Initial load duke parents: diff changeset	89 // are not accepted. If you need to make an assertion about an
a61af66fc99e Initial load duke parents: diff changeset	90 // array type, make the assertion about its corresponding element
a61af66fc99e Initial load duke parents: diff changeset	91 // types. Any assertion that might change about an array type can
a61af66fc99e Initial load duke parents: diff changeset	92 // be converted to an assertion about its element type.
a61af66fc99e Initial load duke parents: diff changeset	93 //
a61af66fc99e Initial load duke parents: diff changeset	94 // Most dependencies are evaluated over a "context type" CX, which
a61af66fc99e Initial load duke parents: diff changeset	95 // stands for the set Subtypes(CX) of every Java type that is a subtype*
a61af66fc99e Initial load duke parents: diff changeset	96 // of CX. When the system loads a new class or interface N, it is
a61af66fc99e Initial load duke parents: diff changeset	97 // responsible for re-evaluating changed dependencies whose context
a61af66fc99e Initial load duke parents: diff changeset	98 // type now includes N, that is, all super types of N.
a61af66fc99e Initial load duke parents: diff changeset	99 //
a61af66fc99e Initial load duke parents: diff changeset	100 enum DepType {
a61af66fc99e Initial load duke parents: diff changeset	101 end_marker = 0,
a61af66fc99e Initial load duke parents: diff changeset	102
a61af66fc99e Initial load duke parents: diff changeset	103 // An 'evol' dependency simply notes that the contents of the
a61af66fc99e Initial load duke parents: diff changeset	104 // method were used. If it evolves (is replaced), the nmethod
a61af66fc99e Initial load duke parents: diff changeset	105 // must be recompiled. No other dependencies are implied.
a61af66fc99e Initial load duke parents: diff changeset	106 evol_method,
a61af66fc99e Initial load duke parents: diff changeset	107 FIRST_TYPE = evol_method,
a61af66fc99e Initial load duke parents: diff changeset	108
a61af66fc99e Initial load duke parents: diff changeset	109 // A context type CX is a leaf it if has no proper subtype.
a61af66fc99e Initial load duke parents: diff changeset	110 leaf_type,
a61af66fc99e Initial load duke parents: diff changeset	111
a61af66fc99e Initial load duke parents: diff changeset	112 // An abstract class CX has exactly one concrete subtype CC.
a61af66fc99e Initial load duke parents: diff changeset	113 abstract_with_unique_concrete_subtype,
a61af66fc99e Initial load duke parents: diff changeset	114
a61af66fc99e Initial load duke parents: diff changeset	115 // The type CX is purely abstract, with no concrete subtype* at all.
a61af66fc99e Initial load duke parents: diff changeset	116 abstract_with_no_concrete_subtype,
a61af66fc99e Initial load duke parents: diff changeset	117
a61af66fc99e Initial load duke parents: diff changeset	118 // The concrete CX is free of concrete proper subtypes.
a61af66fc99e Initial load duke parents: diff changeset	119 concrete_with_no_concrete_subtype,
a61af66fc99e Initial load duke parents: diff changeset	120
a61af66fc99e Initial load duke parents: diff changeset	121 // Given a method M1 and a context class CX, the set MM(CX, M1) of
a61af66fc99e Initial load duke parents: diff changeset	122 // "concrete matching methods" in CX of M1 is the set of every
a61af66fc99e Initial load duke parents: diff changeset	123 // concrete M2 for which it is possible to create an invokevirtual
a61af66fc99e Initial load duke parents: diff changeset	124 // or invokeinterface call site that can reach either M1 or M2.
a61af66fc99e Initial load duke parents: diff changeset	125 // That is, M1 and M2 share a name, signature, and vtable index.
a61af66fc99e Initial load duke parents: diff changeset	126 // We wish to notice when the set MM(CX, M1) is just {M1}, or
a61af66fc99e Initial load duke parents: diff changeset	127 // perhaps a set of two {M1,M2}, and issue dependencies on this.
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 // The set MM(CX, M1) can be computed by starting with any matching
a61af66fc99e Initial load duke parents: diff changeset	130 // concrete M2 that is inherited into CX, and then walking the
a61af66fc99e Initial load duke parents: diff changeset	131 // subtypes* of CX looking for concrete definitions.
a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 // The parameters to this dependency are the method M1 and the
a61af66fc99e Initial load duke parents: diff changeset	134 // context class CX. M1 must be either inherited in CX or defined
a61af66fc99e Initial load duke parents: diff changeset	135 // in a subtype* of CX. It asserts that MM(CX, M1) is no greater
a61af66fc99e Initial load duke parents: diff changeset	136 // than {M1}.
a61af66fc99e Initial load duke parents: diff changeset	137 unique_concrete_method, // one unique concrete method under CX
a61af66fc99e Initial load duke parents: diff changeset	138
a61af66fc99e Initial load duke parents: diff changeset	139 // An "exclusive" assertion concerns two methods or subtypes, and
a61af66fc99e Initial load duke parents: diff changeset	140 // declares that there are at most two (or perhaps later N>2)
a61af66fc99e Initial load duke parents: diff changeset	141 // specific items that jointly satisfy the restriction.
a61af66fc99e Initial load duke parents: diff changeset	142 // We list all items explicitly rather than just giving their
a61af66fc99e Initial load duke parents: diff changeset	143 // count, for robustness in the face of complex schema changes.
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145 // A context class CX (which may be either abstract or concrete)
a61af66fc99e Initial load duke parents: diff changeset	146 // has two exclusive concrete subtypes* C1, C2 if every concrete
a61af66fc99e Initial load duke parents: diff changeset	147 // subtype* of CX is either C1 or C2. Note that if neither C1 or C2
a61af66fc99e Initial load duke parents: diff changeset	148 // are equal to CX, then CX itself must be abstract. But it is
a61af66fc99e Initial load duke parents: diff changeset	149 // also possible (for example) that C1 is CX (a concrete class)
a61af66fc99e Initial load duke parents: diff changeset	150 // and C2 is a proper subtype of C1.
a61af66fc99e Initial load duke parents: diff changeset	151 abstract_with_exclusive_concrete_subtypes_2,
a61af66fc99e Initial load duke parents: diff changeset	152
a61af66fc99e Initial load duke parents: diff changeset	153 // This dependency asserts that MM(CX, M1) is no greater than {M1,M2}.
a61af66fc99e Initial load duke parents: diff changeset	154 exclusive_concrete_methods_2,
a61af66fc99e Initial load duke parents: diff changeset	155
a61af66fc99e Initial load duke parents: diff changeset	156 // This dependency asserts that no instances of class or it's
a61af66fc99e Initial load duke parents: diff changeset	157 // subclasses require finalization registration.
a61af66fc99e Initial load duke parents: diff changeset	158 no_finalizable_subclasses,
a61af66fc99e Initial load duke parents: diff changeset	159
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	160 // This dependency asserts when the CallSite.target value changed.
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	161 call_site_target_value,
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	162
0 a61af66fc99e Initial load duke parents: diff changeset	163 TYPE_LIMIT
a61af66fc99e Initial load duke parents: diff changeset	164 };
a61af66fc99e Initial load duke parents: diff changeset	165 enum {
a61af66fc99e Initial load duke parents: diff changeset	166 LG2_TYPE_LIMIT = 4, // assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT))
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 // handy categorizations of dependency types:
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	169 all_types = ((1 << TYPE_LIMIT) - 1) & ((-1) << FIRST_TYPE),
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	170
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	171 non_klass_types = (1 << call_site_target_value),
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	172 klass_types = all_types & ~non_klass_types,
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	173
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	174 non_ctxk_types = (1 << evol_method),
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	175 implicit_ctxk_types = (1 << call_site_target_value),
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	176 explicit_ctxk_types = all_types & ~(non_ctxk_types \| implicit_ctxk_types),
0 a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 max_arg_count = 3, // current maximum number of arguments (incl. ctxk)
a61af66fc99e Initial load duke parents: diff changeset	179
a61af66fc99e Initial load duke parents: diff changeset	180 // A "context type" is a class or interface that
a61af66fc99e Initial load duke parents: diff changeset	181 // provides context for evaluating a dependency.
a61af66fc99e Initial load duke parents: diff changeset	182 // When present, it is one of the arguments (dep_context_arg).
a61af66fc99e Initial load duke parents: diff changeset	183 //
a61af66fc99e Initial load duke parents: diff changeset	184 // If a dependency does not have a context type, there is a
a61af66fc99e Initial load duke parents: diff changeset	185 // default context, depending on the type of the dependency.
a61af66fc99e Initial load duke parents: diff changeset	186 // This bit signals that a default context has been compressed away.
a61af66fc99e Initial load duke parents: diff changeset	187 default_context_type_bit = (1<<LG2_TYPE_LIMIT)
a61af66fc99e Initial load duke parents: diff changeset	188 };
a61af66fc99e Initial load duke parents: diff changeset	189
a61af66fc99e Initial load duke parents: diff changeset	190 static const char* dep_name(DepType dept);
a61af66fc99e Initial load duke parents: diff changeset	191 static int dep_args(DepType dept);
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	192
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	193 static bool is_klass_type( DepType dept) { return dept_in_mask(dept, klass_types ); }
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	194
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	195 static bool has_explicit_context_arg(DepType dept) { return dept_in_mask(dept, explicit_ctxk_types); }
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	196 static bool has_implicit_context_arg(DepType dept) { return dept_in_mask(dept, implicit_ctxk_types); }
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	197
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	198 static int dep_context_arg(DepType dept) { return has_explicit_context_arg(dept) ? 0 : -1; }
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	199 static int dep_implicit_context_arg(DepType dept) { return has_implicit_context_arg(dept) ? 0 : -1; }
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	200
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	201 static void check_valid_dependency_type(DepType dept);
0 a61af66fc99e Initial load duke parents: diff changeset	202
a61af66fc99e Initial load duke parents: diff changeset	203 private:
a61af66fc99e Initial load duke parents: diff changeset	204 // State for writing a new set of dependencies:
a61af66fc99e Initial load duke parents: diff changeset	205 GrowableArray<int>* _dep_seen; // (seen[h->ident] & (1<<dept))
a61af66fc99e Initial load duke parents: diff changeset	206 GrowableArray<ciObject> _deps[TYPE_LIMIT];
a61af66fc99e Initial load duke parents: diff changeset	207
a61af66fc99e Initial load duke parents: diff changeset	208 static const char* _dep_name[TYPE_LIMIT];
a61af66fc99e Initial load duke parents: diff changeset	209 static int _dep_args[TYPE_LIMIT];
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211 static bool dept_in_mask(DepType dept, int mask) {
a61af66fc99e Initial load duke parents: diff changeset	212 return (int)dept >= 0 && dept < TYPE_LIMIT && ((1<<dept) & mask) != 0;
a61af66fc99e Initial load duke parents: diff changeset	213 }
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 bool note_dep_seen(int dept, ciObject* x) {
a61af66fc99e Initial load duke parents: diff changeset	216 assert(dept < BitsPerInt, "oob");
a61af66fc99e Initial load duke parents: diff changeset	217 int x_id = x->ident();
a61af66fc99e Initial load duke parents: diff changeset	218 assert(_dep_seen != NULL, "deps must be writable");
a61af66fc99e Initial load duke parents: diff changeset	219 int seen = _dep_seen->at_grow(x_id, 0);
a61af66fc99e Initial load duke parents: diff changeset	220 _dep_seen->at_put(x_id, seen \| (1<<dept));
a61af66fc99e Initial load duke parents: diff changeset	221 // return true if we've already seen dept/x
a61af66fc99e Initial load duke parents: diff changeset	222 return (seen & (1<<dept)) != 0;
a61af66fc99e Initial load duke parents: diff changeset	223 }
a61af66fc99e Initial load duke parents: diff changeset	224
a61af66fc99e Initial load duke parents: diff changeset	225 bool maybe_merge_ctxk(GrowableArray<ciObject> deps,
a61af66fc99e Initial load duke parents: diff changeset	226 int ctxk_i, ciKlass* ctxk);
a61af66fc99e Initial load duke parents: diff changeset	227
a61af66fc99e Initial load duke parents: diff changeset	228 void sort_all_deps();
a61af66fc99e Initial load duke parents: diff changeset	229 size_t estimate_size_in_bytes();
a61af66fc99e Initial load duke parents: diff changeset	230
a61af66fc99e Initial load duke parents: diff changeset	231 // Initialize _deps, etc.
a61af66fc99e Initial load duke parents: diff changeset	232 void initialize(ciEnv* env);
a61af66fc99e Initial load duke parents: diff changeset	233
a61af66fc99e Initial load duke parents: diff changeset	234 // State for making a new set of dependencies:
a61af66fc99e Initial load duke parents: diff changeset	235 OopRecorder* _oop_recorder;
a61af66fc99e Initial load duke parents: diff changeset	236
a61af66fc99e Initial load duke parents: diff changeset	237 // Logging support
a61af66fc99e Initial load duke parents: diff changeset	238 CompileLog* _log;
a61af66fc99e Initial load duke parents: diff changeset	239
a61af66fc99e Initial load duke parents: diff changeset	240 address _content_bytes; // everything but the oop references, encoded
a61af66fc99e Initial load duke parents: diff changeset	241 size_t _size_in_bytes;
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243 public:
a61af66fc99e Initial load duke parents: diff changeset	244 // Make a new empty dependencies set.
a61af66fc99e Initial load duke parents: diff changeset	245 Dependencies(ciEnv* env) {
a61af66fc99e Initial load duke parents: diff changeset	246 initialize(env);
a61af66fc99e Initial load duke parents: diff changeset	247 }
a61af66fc99e Initial load duke parents: diff changeset	248
a61af66fc99e Initial load duke parents: diff changeset	249 private:
a61af66fc99e Initial load duke parents: diff changeset	250 // Check for a valid context type.
a61af66fc99e Initial load duke parents: diff changeset	251 // Enforce the restriction against array types.
a61af66fc99e Initial load duke parents: diff changeset	252 static void check_ctxk(ciKlass* ctxk) {
a61af66fc99e Initial load duke parents: diff changeset	253 assert(ctxk->is_instance_klass(), "java types only");
a61af66fc99e Initial load duke parents: diff changeset	254 }
a61af66fc99e Initial load duke parents: diff changeset	255 static void check_ctxk_concrete(ciKlass* ctxk) {
a61af66fc99e Initial load duke parents: diff changeset	256 assert(is_concrete_klass(ctxk->as_instance_klass()), "must be concrete");
a61af66fc99e Initial load duke parents: diff changeset	257 }
a61af66fc99e Initial load duke parents: diff changeset	258 static void check_ctxk_abstract(ciKlass* ctxk) {
a61af66fc99e Initial load duke parents: diff changeset	259 check_ctxk(ctxk);
a61af66fc99e Initial load duke parents: diff changeset	260 assert(!is_concrete_klass(ctxk->as_instance_klass()), "must be abstract");
a61af66fc99e Initial load duke parents: diff changeset	261 }
a61af66fc99e Initial load duke parents: diff changeset	262
a61af66fc99e Initial load duke parents: diff changeset	263 void assert_common_1(DepType dept, ciObject* x);
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	264 void assert_common_2(DepType dept, ciObject* x0, ciObject* x1);
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	265 void assert_common_3(DepType dept, ciKlass* ctxk, ciObject* x1, ciObject* x2);
0 a61af66fc99e Initial load duke parents: diff changeset	266
a61af66fc99e Initial load duke parents: diff changeset	267 public:
a61af66fc99e Initial load duke parents: diff changeset	268 // Adding assertions to a new dependency set at compile time:
a61af66fc99e Initial load duke parents: diff changeset	269 void assert_evol_method(ciMethod* m);
a61af66fc99e Initial load duke parents: diff changeset	270 void assert_leaf_type(ciKlass* ctxk);
a61af66fc99e Initial load duke parents: diff changeset	271 void assert_abstract_with_unique_concrete_subtype(ciKlass* ctxk, ciKlass* conck);
a61af66fc99e Initial load duke parents: diff changeset	272 void assert_abstract_with_no_concrete_subtype(ciKlass* ctxk);
a61af66fc99e Initial load duke parents: diff changeset	273 void assert_concrete_with_no_concrete_subtype(ciKlass* ctxk);
a61af66fc99e Initial load duke parents: diff changeset	274 void assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm);
a61af66fc99e Initial load duke parents: diff changeset	275 void assert_abstract_with_exclusive_concrete_subtypes(ciKlass* ctxk, ciKlass* k1, ciKlass* k2);
a61af66fc99e Initial load duke parents: diff changeset	276 void assert_exclusive_concrete_methods(ciKlass* ctxk, ciMethod* m1, ciMethod* m2);
a61af66fc99e Initial load duke parents: diff changeset	277 void assert_has_no_finalizable_subclasses(ciKlass* ctxk);
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	278 void assert_call_site_target_value(ciCallSite* call_site, ciMethodHandle* method_handle);
0 a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 // Define whether a given method or type is concrete.
a61af66fc99e Initial load duke parents: diff changeset	281 // These methods define the term "concrete" as used in this module.
a61af66fc99e Initial load duke parents: diff changeset	282 // For this module, an "abstract" class is one which is non-concrete.
a61af66fc99e Initial load duke parents: diff changeset	283 //
a61af66fc99e Initial load duke parents: diff changeset	284 // Future optimizations may allow some classes to remain
a61af66fc99e Initial load duke parents: diff changeset	285 // non-concrete until their first instantiation, and allow some
a61af66fc99e Initial load duke parents: diff changeset	286 // methods to remain non-concrete until their first invocation.
a61af66fc99e Initial load duke parents: diff changeset	287 // In that case, there would be a middle ground between concrete
a61af66fc99e Initial load duke parents: diff changeset	288 // and abstract (as defined by the Java language and VM).
a61af66fc99e Initial load duke parents: diff changeset	289 static bool is_concrete_klass(klassOop k); // k is instantiable
a61af66fc99e Initial load duke parents: diff changeset	290 static bool is_concrete_method(methodOop m); // m is invocable
a61af66fc99e Initial load duke parents: diff changeset	291 static Klass* find_finalizable_subclass(Klass* k);
a61af66fc99e Initial load duke parents: diff changeset	292
a61af66fc99e Initial load duke parents: diff changeset	293 // These versions of the concreteness queries work through the CI.
a61af66fc99e Initial load duke parents: diff changeset	294 // The CI versions are allowed to skew sometimes from the VM
a61af66fc99e Initial load duke parents: diff changeset	295 // (oop-based) versions. The cost of such a difference is a
a61af66fc99e Initial load duke parents: diff changeset	296 // (safely) aborted compilation, or a deoptimization, or a missed
a61af66fc99e Initial load duke parents: diff changeset	297 // optimization opportunity.
a61af66fc99e Initial load duke parents: diff changeset	298 //
a61af66fc99e Initial load duke parents: diff changeset	299 // In order to prevent spurious assertions, query results must
a61af66fc99e Initial load duke parents: diff changeset	300 // remain stable within any single ciEnv instance. (I.e., they must
a61af66fc99e Initial load duke parents: diff changeset	301 // not go back into the VM to get their value; they must cache the
a61af66fc99e Initial load duke parents: diff changeset	302 // bit in the CI, either eagerly or lazily.)
a61af66fc99e Initial load duke parents: diff changeset	303 static bool is_concrete_klass(ciInstanceKlass* k); // k appears instantiable
a61af66fc99e Initial load duke parents: diff changeset	304 static bool is_concrete_method(ciMethod* m); // m appears invocable
a61af66fc99e Initial load duke parents: diff changeset	305 static bool has_finalizable_subclass(ciInstanceKlass* k);
a61af66fc99e Initial load duke parents: diff changeset	306
a61af66fc99e Initial load duke parents: diff changeset	307 // As a general rule, it is OK to compile under the assumption that
a61af66fc99e Initial load duke parents: diff changeset	308 // a given type or method is concrete, even if it at some future
a61af66fc99e Initial load duke parents: diff changeset	309 // point becomes abstract. So dependency checking is one-sided, in
a61af66fc99e Initial load duke parents: diff changeset	310 // that it permits supposedly concrete classes or methods to turn up
a61af66fc99e Initial load duke parents: diff changeset	311 // as really abstract. (This shouldn't happen, except during class
a61af66fc99e Initial load duke parents: diff changeset	312 // evolution, but that's the logic of the checking.) However, if a
a61af66fc99e Initial load duke parents: diff changeset	313 // supposedly abstract class or method suddenly becomes concrete, a
a61af66fc99e Initial load duke parents: diff changeset	314 // dependency on it must fail.
a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 // Checking old assertions at run-time (in the VM only):
a61af66fc99e Initial load duke parents: diff changeset	317 static klassOop check_evol_method(methodOop m);
a61af66fc99e Initial load duke parents: diff changeset	318 static klassOop check_leaf_type(klassOop ctxk);
a61af66fc99e Initial load duke parents: diff changeset	319 static klassOop check_abstract_with_unique_concrete_subtype(klassOop ctxk, klassOop conck,
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	320 KlassDepChange* changes = NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	321 static klassOop check_abstract_with_no_concrete_subtype(klassOop ctxk,
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	322 KlassDepChange* changes = NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	323 static klassOop check_concrete_with_no_concrete_subtype(klassOop ctxk,
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	324 KlassDepChange* changes = NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	325 static klassOop check_unique_concrete_method(klassOop ctxk, methodOop uniqm,
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	326 KlassDepChange* changes = NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	327 static klassOop check_abstract_with_exclusive_concrete_subtypes(klassOop ctxk, klassOop k1, klassOop k2,
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	328 KlassDepChange* changes = NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	329 static klassOop check_exclusive_concrete_methods(klassOop ctxk, methodOop m1, methodOop m2,
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	330 KlassDepChange* changes = NULL);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	331 static klassOop check_has_no_finalizable_subclasses(klassOop ctxk, KlassDepChange* changes = NULL);
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	332 static klassOop check_call_site_target_value(oop call_site, oop method_handle, CallSiteDepChange* changes = NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	333 // A returned klassOop is NULL if the dependency assertion is still
a61af66fc99e Initial load duke parents: diff changeset	334 // valid. A non-NULL klassOop is a 'witness' to the assertion
a61af66fc99e Initial load duke parents: diff changeset	335 // failure, a point in the class hierarchy where the assertion has
a61af66fc99e Initial load duke parents: diff changeset	336 // been proven false. For example, if check_leaf_type returns
a61af66fc99e Initial load duke parents: diff changeset	337 // non-NULL, the value is a subtype of the supposed leaf type. This
a61af66fc99e Initial load duke parents: diff changeset	338 // witness value may be useful for logging the dependency failure.
a61af66fc99e Initial load duke parents: diff changeset	339 // Note that, when a dependency fails, there may be several possible
a61af66fc99e Initial load duke parents: diff changeset	340 // witnesses to the failure. The value returned from the check_foo
a61af66fc99e Initial load duke parents: diff changeset	341 // method is chosen arbitrarily.
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 // The 'changes' value, if non-null, requests a limited spot-check
a61af66fc99e Initial load duke parents: diff changeset	344 // near the indicated recent changes in the class hierarchy.
a61af66fc99e Initial load duke parents: diff changeset	345 // It is used by DepStream::spot_check_dependency_at.
a61af66fc99e Initial load duke parents: diff changeset	346
a61af66fc99e Initial load duke parents: diff changeset	347 // Detecting possible new assertions:
a61af66fc99e Initial load duke parents: diff changeset	348 static klassOop find_unique_concrete_subtype(klassOop ctxk);
a61af66fc99e Initial load duke parents: diff changeset	349 static methodOop find_unique_concrete_method(klassOop ctxk, methodOop m);
a61af66fc99e Initial load duke parents: diff changeset	350 static int find_exclusive_concrete_subtypes(klassOop ctxk, int klen, klassOop k[]);
a61af66fc99e Initial load duke parents: diff changeset	351 static int find_exclusive_concrete_methods(klassOop ctxk, int mlen, methodOop m[]);
a61af66fc99e Initial load duke parents: diff changeset	352
a61af66fc99e Initial load duke parents: diff changeset	353 // Create the encoding which will be stored in an nmethod.
a61af66fc99e Initial load duke parents: diff changeset	354 void encode_content_bytes();
a61af66fc99e Initial load duke parents: diff changeset	355
a61af66fc99e Initial load duke parents: diff changeset	356 address content_bytes() {
a61af66fc99e Initial load duke parents: diff changeset	357 assert(_content_bytes != NULL, "encode it first");
a61af66fc99e Initial load duke parents: diff changeset	358 return _content_bytes;
a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360 size_t size_in_bytes() {
a61af66fc99e Initial load duke parents: diff changeset	361 assert(_content_bytes != NULL, "encode it first");
a61af66fc99e Initial load duke parents: diff changeset	362 return _size_in_bytes;
a61af66fc99e Initial load duke parents: diff changeset	363 }
a61af66fc99e Initial load duke parents: diff changeset	364
a61af66fc99e Initial load duke parents: diff changeset	365 OopRecorder* oop_recorder() { return _oop_recorder; }
a61af66fc99e Initial load duke parents: diff changeset	366 CompileLog* log() { return _log; }
a61af66fc99e Initial load duke parents: diff changeset	367
a61af66fc99e Initial load duke parents: diff changeset	368 void copy_to(nmethod* nm);
a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370 void log_all_dependencies();
a61af66fc99e Initial load duke parents: diff changeset	371 void log_dependency(DepType dept, int nargs, ciObject* args[]) {
a61af66fc99e Initial load duke parents: diff changeset	372 write_dependency_to(log(), dept, nargs, args);
a61af66fc99e Initial load duke parents: diff changeset	373 }
a61af66fc99e Initial load duke parents: diff changeset	374 void log_dependency(DepType dept,
a61af66fc99e Initial load duke parents: diff changeset	375 ciObject* x0,
a61af66fc99e Initial load duke parents: diff changeset	376 ciObject* x1 = NULL,
a61af66fc99e Initial load duke parents: diff changeset	377 ciObject* x2 = NULL) {
a61af66fc99e Initial load duke parents: diff changeset	378 if (log() == NULL) return;
a61af66fc99e Initial load duke parents: diff changeset	379 ciObject* args[max_arg_count];
a61af66fc99e Initial load duke parents: diff changeset	380 args[0] = x0;
a61af66fc99e Initial load duke parents: diff changeset	381 args[1] = x1;
a61af66fc99e Initial load duke parents: diff changeset	382 args[2] = x2;
a61af66fc99e Initial load duke parents: diff changeset	383 assert(2 < max_arg_count, "");
a61af66fc99e Initial load duke parents: diff changeset	384 log_dependency(dept, dep_args(dept), args);
a61af66fc99e Initial load duke parents: diff changeset	385 }
a61af66fc99e Initial load duke parents: diff changeset	386
a61af66fc99e Initial load duke parents: diff changeset	387 static void write_dependency_to(CompileLog* log,
a61af66fc99e Initial load duke parents: diff changeset	388 DepType dept,
a61af66fc99e Initial load duke parents: diff changeset	389 int nargs, ciObject* args[],
a61af66fc99e Initial load duke parents: diff changeset	390 klassOop witness = NULL);
a61af66fc99e Initial load duke parents: diff changeset	391 static void write_dependency_to(CompileLog* log,
a61af66fc99e Initial load duke parents: diff changeset	392 DepType dept,
a61af66fc99e Initial load duke parents: diff changeset	393 int nargs, oop args[],
a61af66fc99e Initial load duke parents: diff changeset	394 klassOop witness = NULL);
a61af66fc99e Initial load duke parents: diff changeset	395 static void write_dependency_to(xmlStream* xtty,
a61af66fc99e Initial load duke parents: diff changeset	396 DepType dept,
a61af66fc99e Initial load duke parents: diff changeset	397 int nargs, oop args[],
a61af66fc99e Initial load duke parents: diff changeset	398 klassOop witness = NULL);
a61af66fc99e Initial load duke parents: diff changeset	399 static void print_dependency(DepType dept,
a61af66fc99e Initial load duke parents: diff changeset	400 int nargs, oop args[],
a61af66fc99e Initial load duke parents: diff changeset	401 klassOop witness = NULL);
a61af66fc99e Initial load duke parents: diff changeset	402
a61af66fc99e Initial load duke parents: diff changeset	403 private:
a61af66fc99e Initial load duke parents: diff changeset	404 // helper for encoding common context types as zero:
a61af66fc99e Initial load duke parents: diff changeset	405 static ciKlass* ctxk_encoded_as_null(DepType dept, ciObject* x);
a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 static klassOop ctxk_encoded_as_null(DepType dept, oop x);
a61af66fc99e Initial load duke parents: diff changeset	408
a61af66fc99e Initial load duke parents: diff changeset	409 public:
a61af66fc99e Initial load duke parents: diff changeset	410 // Use this to iterate over an nmethod's dependency set.
a61af66fc99e Initial load duke parents: diff changeset	411 // Works on new and old dependency sets.
a61af66fc99e Initial load duke parents: diff changeset	412 // Usage:
a61af66fc99e Initial load duke parents: diff changeset	413 //
a61af66fc99e Initial load duke parents: diff changeset	414 // ;
a61af66fc99e Initial load duke parents: diff changeset	415 // Dependencies::DepType dept;
a61af66fc99e Initial load duke parents: diff changeset	416 // for (Dependencies::DepStream deps(nm); deps.next(); ) {
a61af66fc99e Initial load duke parents: diff changeset	417 // ...
a61af66fc99e Initial load duke parents: diff changeset	418 // }
a61af66fc99e Initial load duke parents: diff changeset	419 //
a61af66fc99e Initial load duke parents: diff changeset	420 // The caller must be in the VM, since oops are not wrapped in handles.
a61af66fc99e Initial load duke parents: diff changeset	421 class DepStream {
a61af66fc99e Initial load duke parents: diff changeset	422 private:
a61af66fc99e Initial load duke parents: diff changeset	423 nmethod* _code; // null if in a compiler thread
a61af66fc99e Initial load duke parents: diff changeset	424 Dependencies* _deps; // null if not in a compiler thread
a61af66fc99e Initial load duke parents: diff changeset	425 CompressedReadStream _bytes;
a61af66fc99e Initial load duke parents: diff changeset	426 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	427 size_t _byte_limit;
a61af66fc99e Initial load duke parents: diff changeset	428 #endif
a61af66fc99e Initial load duke parents: diff changeset	429
a61af66fc99e Initial load duke parents: diff changeset	430 // iteration variables:
a61af66fc99e Initial load duke parents: diff changeset	431 DepType _type;
a61af66fc99e Initial load duke parents: diff changeset	432 int _xi[max_arg_count+1];
a61af66fc99e Initial load duke parents: diff changeset	433
a61af66fc99e Initial load duke parents: diff changeset	434 void initial_asserts(size_t byte_limit) NOT_DEBUG({});
a61af66fc99e Initial load duke parents: diff changeset	435
a61af66fc99e Initial load duke parents: diff changeset	436 inline oop recorded_oop_at(int i);
a61af66fc99e Initial load duke parents: diff changeset	437 // => _code? _code->oop_at(i): *_deps->_oop_recorder->handle_at(i)
a61af66fc99e Initial load duke parents: diff changeset	438
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	439 klassOop check_klass_dependency(KlassDepChange* changes);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	440 klassOop check_call_site_dependency(CallSiteDepChange* changes);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	441
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	442 void trace_and_log_witness(klassOop witness);
0 a61af66fc99e Initial load duke parents: diff changeset	443
a61af66fc99e Initial load duke parents: diff changeset	444 public:
a61af66fc99e Initial load duke parents: diff changeset	445 DepStream(Dependencies* deps)
a61af66fc99e Initial load duke parents: diff changeset	446 : _deps(deps),
a61af66fc99e Initial load duke parents: diff changeset	447 _code(NULL),
a61af66fc99e Initial load duke parents: diff changeset	448 _bytes(deps->content_bytes())
a61af66fc99e Initial load duke parents: diff changeset	449 {
a61af66fc99e Initial load duke parents: diff changeset	450 initial_asserts(deps->size_in_bytes());
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 DepStream(nmethod* code)
a61af66fc99e Initial load duke parents: diff changeset	453 : _deps(NULL),
a61af66fc99e Initial load duke parents: diff changeset	454 _code(code),
a61af66fc99e Initial load duke parents: diff changeset	455 _bytes(code->dependencies_begin())
a61af66fc99e Initial load duke parents: diff changeset	456 {
a61af66fc99e Initial load duke parents: diff changeset	457 initial_asserts(code->dependencies_size());
a61af66fc99e Initial load duke parents: diff changeset	458 }
a61af66fc99e Initial load duke parents: diff changeset	459
a61af66fc99e Initial load duke parents: diff changeset	460 bool next();
a61af66fc99e Initial load duke parents: diff changeset	461
a61af66fc99e Initial load duke parents: diff changeset	462 DepType type() { return _type; }
a61af66fc99e Initial load duke parents: diff changeset	463 int argument_count() { return dep_args(type()); }
a61af66fc99e Initial load duke parents: diff changeset	464 int argument_index(int i) { assert(0 <= i && i < argument_count(), "oob");
a61af66fc99e Initial load duke parents: diff changeset	465 return _xi[i]; }
a61af66fc99e Initial load duke parents: diff changeset	466 oop argument(int i); // => recorded_oop_at(argument_index(i))
a61af66fc99e Initial load duke parents: diff changeset	467 klassOop context_type();
a61af66fc99e Initial load duke parents: diff changeset	468
3894 b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	469 bool is_klass_type() { return Dependencies::is_klass_type(type()); }
b27c72d69fd1 7083184: JSR 292: don't store context class argument with call site dependencies twisti parents: 3852 diff changeset	470
0 a61af66fc99e Initial load duke parents: diff changeset	471 methodOop method_argument(int i) {
a61af66fc99e Initial load duke parents: diff changeset	472 oop x = argument(i);
a61af66fc99e Initial load duke parents: diff changeset	473 assert(x->is_method(), "type");
a61af66fc99e Initial load duke parents: diff changeset	474 return (methodOop) x;
a61af66fc99e Initial load duke parents: diff changeset	475 }
a61af66fc99e Initial load duke parents: diff changeset	476 klassOop type_argument(int i) {
a61af66fc99e Initial load duke parents: diff changeset	477 oop x = argument(i);
a61af66fc99e Initial load duke parents: diff changeset	478 assert(x->is_klass(), "type");
a61af66fc99e Initial load duke parents: diff changeset	479 return (klassOop) x;
a61af66fc99e Initial load duke parents: diff changeset	480 }
a61af66fc99e Initial load duke parents: diff changeset	481
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	482 // The point of the whole exercise: Is this dep still OK?
0 a61af66fc99e Initial load duke parents: diff changeset	483 klassOop check_dependency() {
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	484 klassOop result = check_klass_dependency(NULL);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	485 if (result != NULL) return result;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	486 return check_call_site_dependency(NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	487 }
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	488
0 a61af66fc99e Initial load duke parents: diff changeset	489 // A lighter version: Checks only around recent changes in a class
a61af66fc99e Initial load duke parents: diff changeset	490 // hierarchy. (See Universe::flush_dependents_on.)
a61af66fc99e Initial load duke parents: diff changeset	491 klassOop spot_check_dependency_at(DepChange& changes);
a61af66fc99e Initial load duke parents: diff changeset	492
a61af66fc99e Initial load duke parents: diff changeset	493 // Log the current dependency to xtty or compilation log.
a61af66fc99e Initial load duke parents: diff changeset	494 void log_dependency(klassOop witness = NULL);
a61af66fc99e Initial load duke parents: diff changeset	495
a61af66fc99e Initial load duke parents: diff changeset	496 // Print the current dependency to tty.
a61af66fc99e Initial load duke parents: diff changeset	497 void print_dependency(klassOop witness = NULL, bool verbose = false);
a61af66fc99e Initial load duke parents: diff changeset	498 };
a61af66fc99e Initial load duke parents: diff changeset	499 friend class Dependencies::DepStream;
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 static void print_statistics() PRODUCT_RETURN;
a61af66fc99e Initial load duke parents: diff changeset	502 };
a61af66fc99e Initial load duke parents: diff changeset	503
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	504
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	505 // Every particular DepChange is a sub-class of this class.
0 a61af66fc99e Initial load duke parents: diff changeset	506 class DepChange : public StackObj {
1123 167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	507 public:
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	508 // What kind of DepChange is this?
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	509 virtual bool is_klass_change() const { return false; }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	510 virtual bool is_call_site_change() const { return false; }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	511
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	512 // Subclass casting with assertions.
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	513 KlassDepChange* as_klass_change() {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	514 assert(is_klass_change(), "bad cast");
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	515 return (KlassDepChange*) this;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	516 }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	517 CallSiteDepChange* as_call_site_change() {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	518 assert(is_call_site_change(), "bad cast");
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	519 return (CallSiteDepChange*) this;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	520 }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	521
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	522 void print();
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	523
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	524 public:
0 a61af66fc99e Initial load duke parents: diff changeset	525 enum ChangeType {
a61af66fc99e Initial load duke parents: diff changeset	526 NO_CHANGE = 0, // an uninvolved klass
a61af66fc99e Initial load duke parents: diff changeset	527 Change_new_type, // a newly loaded type
a61af66fc99e Initial load duke parents: diff changeset	528 Change_new_sub, // a super with a new subtype
a61af66fc99e Initial load duke parents: diff changeset	529 Change_new_impl, // an interface with a new implementation
a61af66fc99e Initial load duke parents: diff changeset	530 CHANGE_LIMIT,
a61af66fc99e Initial load duke parents: diff changeset	531 Start_Klass = CHANGE_LIMIT // internal indicator for ContextStream
a61af66fc99e Initial load duke parents: diff changeset	532 };
a61af66fc99e Initial load duke parents: diff changeset	533
a61af66fc99e Initial load duke parents: diff changeset	534 // Usage:
a61af66fc99e Initial load duke parents: diff changeset	535 // for (DepChange::ContextStream str(changes); str.next(); ) {
a61af66fc99e Initial load duke parents: diff changeset	536 // klassOop k = str.klass();
a61af66fc99e Initial load duke parents: diff changeset	537 // switch (str.change_type()) {
a61af66fc99e Initial load duke parents: diff changeset	538 // ...
a61af66fc99e Initial load duke parents: diff changeset	539 // }
a61af66fc99e Initial load duke parents: diff changeset	540 // }
a61af66fc99e Initial load duke parents: diff changeset	541 class ContextStream : public StackObj {
a61af66fc99e Initial load duke parents: diff changeset	542 private:
1123 167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	543 DepChange& _changes;
0 a61af66fc99e Initial load duke parents: diff changeset	544 friend class DepChange;
a61af66fc99e Initial load duke parents: diff changeset	545
a61af66fc99e Initial load duke parents: diff changeset	546 // iteration variables:
1123 167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	547 ChangeType _change_type;
167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	548 klassOop _klass;
167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	549 objArrayOop _ti_base; // i.e., transitive_interfaces
167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	550 int _ti_index;
167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	551 int _ti_limit;
0 a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553 // start at the beginning:
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	554 void start();
0 a61af66fc99e Initial load duke parents: diff changeset	555
1123 167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	556 public:
0 a61af66fc99e Initial load duke parents: diff changeset	557 ContextStream(DepChange& changes)
a61af66fc99e Initial load duke parents: diff changeset	558 : _changes(changes)
a61af66fc99e Initial load duke parents: diff changeset	559 { start(); }
a61af66fc99e Initial load duke parents: diff changeset	560
a61af66fc99e Initial load duke parents: diff changeset	561 ContextStream(DepChange& changes, No_Safepoint_Verifier& nsv)
a61af66fc99e Initial load duke parents: diff changeset	562 : _changes(changes)
a61af66fc99e Initial load duke parents: diff changeset	563 // the nsv argument makes it safe to hold oops like _klass
a61af66fc99e Initial load duke parents: diff changeset	564 { start(); }
a61af66fc99e Initial load duke parents: diff changeset	565
a61af66fc99e Initial load duke parents: diff changeset	566 bool next();
a61af66fc99e Initial load duke parents: diff changeset	567
1123 167c2986d91b 6843629: Make current hotspot build part of jdk5 control build phh parents: 0 diff changeset	568 ChangeType change_type() { return _change_type; }
0 a61af66fc99e Initial load duke parents: diff changeset	569 klassOop klass() { return _klass; }
a61af66fc99e Initial load duke parents: diff changeset	570 };
a61af66fc99e Initial load duke parents: diff changeset	571 friend class DepChange::ContextStream;
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	572 };
0 a61af66fc99e Initial load duke parents: diff changeset	573
3852 fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	574
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	575 // A class hierarchy change coming through the VM (under the Compile_lock).
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	576 // The change is structured as a single new type with any number of supers
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	577 // and implemented interface types. Other than the new type, any of the
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	578 // super types can be context types for a relevant dependency, which the
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	579 // new type could invalidate.
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	580 class KlassDepChange : public DepChange {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	581 private:
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	582 // each change set is rooted in exactly one new type (at present):
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	583 KlassHandle _new_type;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	584
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	585 void initialize();
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	586
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	587 public:
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	588 // notes the new type, marks it and all its super-types
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	589 KlassDepChange(KlassHandle new_type)
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	590 : _new_type(new_type)
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	591 {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	592 initialize();
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	593 }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	594
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	595 // cleans up the marks
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	596 ~KlassDepChange();
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	597
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	598 // What kind of DepChange is this?
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	599 virtual bool is_klass_change() const { return true; }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	600
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	601 klassOop new_type() { return _new_type(); }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	602
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	603 // involves_context(k) is true if k is new_type or any of the super types
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	604 bool involves_context(klassOop k);
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	605 };
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	606
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	607
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	608 // A CallSite has changed its target.
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	609 class CallSiteDepChange : public DepChange {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	610 private:
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	611 Handle _call_site;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	612 Handle _method_handle;
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	613
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	614 public:
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	615 CallSiteDepChange(Handle call_site, Handle method_handle)
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	616 : _call_site(call_site),
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	617 _method_handle(method_handle)
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	618 {
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	619 assert(_call_site() ->is_a(SystemDictionary::CallSite_klass()), "must be");
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	620 assert(_method_handle()->is_a(SystemDictionary::MethodHandle_klass()), "must be");
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	621 }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	622
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	623 // What kind of DepChange is this?
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	624 virtual bool is_call_site_change() const { return true; }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	625
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	626 oop call_site() const { return _call_site(); }
fdb992d83a87 7071653: JSR 292: call site change notification should be pushed not pulled twisti parents: 1972 diff changeset	627 oop method_handle() const { return _method_handle(); }
0 a61af66fc99e Initial load duke parents: diff changeset	628 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	629
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1552 diff changeset	630 #endif // SHARE_VM_CODE_DEPENDENCIES_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/code/dependencies.hpp @ 3992:d1bdeef3e3e2