Mercurial > hg > graal-compiler

comparison src/share/vm/code/dependencies.hpp @ 3894:b27c72d69fd1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7083184: JSR 292: don't store context class argument with call site dependencies Reviewed-by: jrose, never
author twisti
date Mon, 29 Aug 2011 05:07:35 -0700
parents fdb992d83a87
children da91efe96a93
comparison
equal deleted inserted replaced
3893:8805f8c1e23e 3894:b27c72d69fd1
164 }; 164 };
165 enum { 165 enum {
166 LG2_TYPE_LIMIT = 4, // assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT)) 166 LG2_TYPE_LIMIT = 4, // assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT))
167 167
168 // handy categorizations of dependency types: 168 // handy categorizations of dependency types:
169 all_types = ((1<<TYPE_LIMIT)-1) & ((-1)<<FIRST_TYPE), 169 all_types = ((1 << TYPE_LIMIT) - 1) & ((-1) << FIRST_TYPE),
170 non_ctxk_types = (1<<evol_method), 170
171 ctxk_types = all_types & ~non_ctxk_types, 171 non_klass_types = (1 << call_site_target_value),
172 klass_types = all_types & ~non_klass_types,
173
174 non_ctxk_types = (1 << evol_method),
175 implicit_ctxk_types = (1 << call_site_target_value),
176 explicit_ctxk_types = all_types & ~(non_ctxk_types | implicit_ctxk_types),
172 177
173 max_arg_count = 3, // current maximum number of arguments (incl. ctxk) 178 max_arg_count = 3, // current maximum number of arguments (incl. ctxk)
174 179
175 // A "context type" is a class or interface that 180 // A "context type" is a class or interface that
176 // provides context for evaluating a dependency. 181 // provides context for evaluating a dependency.
182 default_context_type_bit = (1<<LG2_TYPE_LIMIT) 187 default_context_type_bit = (1<<LG2_TYPE_LIMIT)
183 }; 188 };
184 189
185 static const char* dep_name(DepType dept); 190 static const char* dep_name(DepType dept);
186 static int dep_args(DepType dept); 191 static int dep_args(DepType dept);
187 static int dep_context_arg(DepType dept) { 192
188 return dept_in_mask(dept, ctxk_types)? 0: -1; 193 static bool is_klass_type( DepType dept) { return dept_in_mask(dept, klass_types ); }
189 } 194
195 static bool has_explicit_context_arg(DepType dept) { return dept_in_mask(dept, explicit_ctxk_types); }
196 static bool has_implicit_context_arg(DepType dept) { return dept_in_mask(dept, implicit_ctxk_types); }
197
198 static int dep_context_arg(DepType dept) { return has_explicit_context_arg(dept) ? 0 : -1; }
199 static int dep_implicit_context_arg(DepType dept) { return has_implicit_context_arg(dept) ? 0 : -1; }
200
190 static void check_valid_dependency_type(DepType dept); 201 static void check_valid_dependency_type(DepType dept);
191 202
192 private: 203 private:
193 // State for writing a new set of dependencies: 204 // State for writing a new set of dependencies:
194 GrowableArray<int>* _dep_seen; // (seen[h->ident] & (1<<dept)) 205 GrowableArray<int>* _dep_seen; // (seen[h->ident] & (1<<dept))
248 check_ctxk(ctxk); 259 check_ctxk(ctxk);
249 assert(!is_concrete_klass(ctxk->as_instance_klass()), "must be abstract"); 260 assert(!is_concrete_klass(ctxk->as_instance_klass()), "must be abstract");
250 } 261 }
251 262
252 void assert_common_1(DepType dept, ciObject* x); 263 void assert_common_1(DepType dept, ciObject* x);
253 void assert_common_2(DepType dept, ciKlass* ctxk, ciObject* x); 264 void assert_common_2(DepType dept, ciObject* x0, ciObject* x1);
254 void assert_common_3(DepType dept, ciKlass* ctxk, ciObject* x, ciObject* x2); 265 void assert_common_3(DepType dept, ciKlass* ctxk, ciObject* x1, ciObject* x2);
255 266
256 public: 267 public:
257 // Adding assertions to a new dependency set at compile time: 268 // Adding assertions to a new dependency set at compile time:
258 void assert_evol_method(ciMethod* m); 269 void assert_evol_method(ciMethod* m);
259 void assert_leaf_type(ciKlass* ctxk); 270 void assert_leaf_type(ciKlass* ctxk);
262 void assert_concrete_with_no_concrete_subtype(ciKlass* ctxk); 273 void assert_concrete_with_no_concrete_subtype(ciKlass* ctxk);
263 void assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm); 274 void assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm);
264 void assert_abstract_with_exclusive_concrete_subtypes(ciKlass* ctxk, ciKlass* k1, ciKlass* k2); 275 void assert_abstract_with_exclusive_concrete_subtypes(ciKlass* ctxk, ciKlass* k1, ciKlass* k2);
265 void assert_exclusive_concrete_methods(ciKlass* ctxk, ciMethod* m1, ciMethod* m2); 276 void assert_exclusive_concrete_methods(ciKlass* ctxk, ciMethod* m1, ciMethod* m2);
266 void assert_has_no_finalizable_subclasses(ciKlass* ctxk); 277 void assert_has_no_finalizable_subclasses(ciKlass* ctxk);
267 void assert_call_site_target_value(ciKlass* ctxk, ciCallSite* call_site, ciMethodHandle* method_handle); 278 void assert_call_site_target_value(ciCallSite* call_site, ciMethodHandle* method_handle);
268 279
269 // Define whether a given method or type is concrete. 280 // Define whether a given method or type is concrete.
270 // These methods define the term "concrete" as used in this module. 281 // These methods define the term "concrete" as used in this module.
271 // For this module, an "abstract" class is one which is non-concrete. 282 // For this module, an "abstract" class is one which is non-concrete.
272 // 283 //
316 static klassOop check_abstract_with_exclusive_concrete_subtypes(klassOop ctxk, klassOop k1, klassOop k2, 327 static klassOop check_abstract_with_exclusive_concrete_subtypes(klassOop ctxk, klassOop k1, klassOop k2,
317 KlassDepChange* changes = NULL); 328 KlassDepChange* changes = NULL);
318 static klassOop check_exclusive_concrete_methods(klassOop ctxk, methodOop m1, methodOop m2, 329 static klassOop check_exclusive_concrete_methods(klassOop ctxk, methodOop m1, methodOop m2,
319 KlassDepChange* changes = NULL); 330 KlassDepChange* changes = NULL);
320 static klassOop check_has_no_finalizable_subclasses(klassOop ctxk, KlassDepChange* changes = NULL); 331 static klassOop check_has_no_finalizable_subclasses(klassOop ctxk, KlassDepChange* changes = NULL);
321 static klassOop check_call_site_target_value(klassOop ctxk, oop call_site, oop method_handle, CallSiteDepChange* changes = NULL); 332 static klassOop check_call_site_target_value(oop call_site, oop method_handle, CallSiteDepChange* changes = NULL);
322 // A returned klassOop is NULL if the dependency assertion is still 333 // A returned klassOop is NULL if the dependency assertion is still
323 // valid. A non-NULL klassOop is a 'witness' to the assertion 334 // valid. A non-NULL klassOop is a 'witness' to the assertion
324 // failure, a point in the class hierarchy where the assertion has 335 // failure, a point in the class hierarchy where the assertion has
325 // been proven false. For example, if check_leaf_type returns 336 // been proven false. For example, if check_leaf_type returns
326 // non-NULL, the value is a subtype of the supposed leaf type. This 337 // non-NULL, the value is a subtype of the supposed leaf type. This
453 int argument_index(int i) { assert(0 <= i && i < argument_count(), "oob"); 464 int argument_index(int i) { assert(0 <= i && i < argument_count(), "oob");
454 return _xi[i]; } 465 return _xi[i]; }
455 oop argument(int i); // => recorded_oop_at(argument_index(i)) 466 oop argument(int i); // => recorded_oop_at(argument_index(i))
456 klassOop context_type(); 467 klassOop context_type();
457 468
469 bool is_klass_type() { return Dependencies::is_klass_type(type()); }
470
458 methodOop method_argument(int i) { 471 methodOop method_argument(int i) {
459 oop x = argument(i); 472 oop x = argument(i);
460 assert(x->is_method(), "type"); 473 assert(x->is_method(), "type");
461 return (methodOop) x; 474 return (methodOop) x;
462 } 475 }