graal-jvmci-8: src/share/vm/code/dependencies.hpp comparison

comparison src/share/vm/code/dependencies.hpp @ 3852:fdb992d83a87

7071653: JSR 292: call site change notification should be pushed not pulled Reviewed-by: kvn, never, bdelsart

author	twisti
date	Tue, 16 Aug 2011 04:14:05 -0700
parents	f95d63e2154a
children	b27c72d69fd1

comparison

equal deleted inserted replaced

-:95134e034042
+:fdb992d83a87
 /*
-* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 */
 #ifndef SHARE_VM_CODE_DEPENDENCIES_HPP
 #define SHARE_VM_CODE_DEPENDENCIES_HPP
+#include "ci/ciCallSite.hpp"
 #include "ci/ciKlass.hpp"
+#include "ci/ciMethodHandle.hpp"
+#include "classfile/systemDictionary.hpp"
 #include "code/compressedStream.hpp"
 #include "code/nmethod.hpp"
 #include "utilities/growableArray.hpp"
 //** Dependencies represent assertions (approximate invariants) within
-// the class hierarchy.  An example is an assertion that a given
+// the runtime system, e.g. class hierarchy changes.  An example is an
-// method is not overridden; another example is that a type has only
+// assertion that a given method is not overridden; another example is
-// one concrete subtype.  Compiled code which relies on such
+// that a type has only one concrete subtype.  Compiled code which
-// assertions must be discarded if they are overturned by changes in
+// relies on such assertions must be discarded if they are overturned
-// the class hierarchy.  We can think of these assertions as
+// by changes in the runtime system.  We can think of these assertions
-// approximate invariants, because we expect them to be overturned
+// as approximate invariants, because we expect them to be overturned
 // very infrequently.  We are willing to perform expensive recovery
 // operations when they are overturned.  The benefit, of course, is
 // performing optimistic optimizations (!) on the object code.
 //
 // Changes in the class hierarchy due to dynamic linking or
 class nmethod;
 class OopRecorder;
 class xmlStream;
 class CompileLog;
 class DepChange;
+class   KlassDepChange;
+class   CallSiteDepChange;
 class No_Safepoint_Verifier;
 class Dependencies: public ResourceObj {
 public:
 // Note: In the comments on dependency types, most uses of the terms
 exclusive_concrete_methods_2,
 // This dependency asserts that no instances of class or it's
 // subclasses require finalization registration.
 no_finalizable_subclasses,
+// This dependency asserts when the CallSite.target value changed.
+call_site_target_value,
 TYPE_LIMIT
 };
 enum {
 LG2_TYPE_LIMIT = 4,  // assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT))
 static const char* dep_name(DepType dept);
 static int         dep_args(DepType dept);
 static int  dep_context_arg(DepType dept) {
 return dept_in_mask(dept, ctxk_types)? 0: -1;
 }
+static void check_valid_dependency_type(DepType dept);
 private:
 // State for writing a new set of dependencies:
 GrowableArray<int>*       _dep_seen;  // (seen[h->ident] & (1<<dept))
 GrowableArray<ciObject*>* _deps[TYPE_LIMIT];
 void assert_concrete_with_no_concrete_subtype(ciKlass* ctxk);
 void assert_unique_concrete_method(ciKlass* ctxk, ciMethod* uniqm);
 void assert_abstract_with_exclusive_concrete_subtypes(ciKlass* ctxk, ciKlass* k1, ciKlass* k2);
 void assert_exclusive_concrete_methods(ciKlass* ctxk, ciMethod* m1, ciMethod* m2);
 void assert_has_no_finalizable_subclasses(ciKlass* ctxk);
+void assert_call_site_target_value(ciKlass* ctxk, ciCallSite* call_site, ciMethodHandle* method_handle);
 // Define whether a given method or type is concrete.
 // These methods define the term "concrete" as used in this module.
 // For this module, an "abstract" class is one which is non-concrete.
 //
 // Checking old assertions at run-time (in the VM only):
 static klassOop check_evol_method(methodOop m);
 static klassOop check_leaf_type(klassOop ctxk);
 static klassOop check_abstract_with_unique_concrete_subtype(klassOop ctxk, klassOop conck,
-DepChange* changes = NULL);
+KlassDepChange* changes = NULL);
 static klassOop check_abstract_with_no_concrete_subtype(klassOop ctxk,
-DepChange* changes = NULL);
+KlassDepChange* changes = NULL);
 static klassOop check_concrete_with_no_concrete_subtype(klassOop ctxk,
-DepChange* changes = NULL);
+KlassDepChange* changes = NULL);
 static klassOop check_unique_concrete_method(klassOop ctxk, methodOop uniqm,
-DepChange* changes = NULL);
+KlassDepChange* changes = NULL);
 static klassOop check_abstract_with_exclusive_concrete_subtypes(klassOop ctxk, klassOop k1, klassOop k2,
-DepChange* changes = NULL);
+KlassDepChange* changes = NULL);
 static klassOop check_exclusive_concrete_methods(klassOop ctxk, methodOop m1, methodOop m2,
-DepChange* changes = NULL);
+KlassDepChange* changes = NULL);
-static klassOop check_has_no_finalizable_subclasses(klassOop ctxk,
+static klassOop check_has_no_finalizable_subclasses(klassOop ctxk, KlassDepChange* changes = NULL);
-DepChange* changes = NULL);
+static klassOop check_call_site_target_value(klassOop ctxk, oop call_site, oop method_handle, CallSiteDepChange* changes = NULL);
 // A returned klassOop is NULL if the dependency assertion is still
 // valid.  A non-NULL klassOop is a 'witness' to the assertion
 // failure, a point in the class hierarchy where the assertion has
 // been proven false.  For example, if check_leaf_type returns
 // non-NULL, the value is a subtype of the supposed leaf type.  This
 void initial_asserts(size_t byte_limit) NOT_DEBUG({});
 inline oop recorded_oop_at(int i);
 // => _code? _code->oop_at(i): *_deps->_oop_recorder->handle_at(i)
-klassOop check_dependency_impl(DepChange* changes);
+klassOop check_klass_dependency(KlassDepChange* changes);
+klassOop check_call_site_dependency(CallSiteDepChange* changes);
+void trace_and_log_witness(klassOop witness);
 public:
 DepStream(Dependencies* deps)
 : _deps(deps),
 _code(NULL),
 oop x = argument(i);
 assert(x->is_klass(), "type");
 return (klassOop) x;
 }
-// The point of the whole exercise:  Is this dep is still OK?
+// The point of the whole exercise:  Is this dep still OK?
 klassOop check_dependency() {
-return check_dependency_impl(NULL);
+klassOop result = check_klass_dependency(NULL);
+if (result != NULL)  return result;
+return check_call_site_dependency(NULL);
 }
 // A lighter version:  Checks only around recent changes in a class
 // hierarchy.  (See Universe::flush_dependents_on.)
 klassOop spot_check_dependency_at(DepChange& changes);
 // Log the current dependency to xtty or compilation log.
 friend class Dependencies::DepStream;
 static void print_statistics() PRODUCT_RETURN;
 };
-// A class hierarchy change coming through the VM (under the Compile_lock).
-// The change is structured as a single new type with any number of supers
+// Every particular DepChange is a sub-class of this class.
-// and implemented interface types.  Other than the new type, any of the
-// super types can be context types for a relevant dependency, which the
-// new type could invalidate.
 class DepChange : public StackObj {
+public:
+// What kind of DepChange is this?
+virtual bool is_klass_change()     const { return false; }
+virtual bool is_call_site_change() const { return false; }
+// Subclass casting with assertions.
+KlassDepChange*    as_klass_change() {
+assert(is_klass_change(), "bad cast");
+return (KlassDepChange*) this;
+}
+CallSiteDepChange* as_call_site_change() {
+assert(is_call_site_change(), "bad cast");
+return (CallSiteDepChange*) this;
+}
+void print();
 public:
 enum ChangeType {
 NO_CHANGE = 0,              // an uninvolved klass
 Change_new_type,            // a newly loaded type
 Change_new_sub,             // a super with a new subtype
 Change_new_impl,            // an interface with a new implementation
 CHANGE_LIMIT,
 Start_Klass = CHANGE_LIMIT  // internal indicator for ContextStream
 };
-private:
-// each change set is rooted in exactly one new type (at present):
-KlassHandle _new_type;
-void initialize();
-public:
-// notes the new type, marks it and all its super-types
-DepChange(KlassHandle new_type)
-: _new_type(new_type)
-{
-initialize();
-}
-// cleans up the marks
-~DepChange();
-klassOop new_type()                   { return _new_type(); }
-// involves_context(k) is true if k is new_type or any of the super types
-bool involves_context(klassOop k);
 // Usage:
 // for (DepChange::ContextStream str(changes); str.next(); ) {
 //   klassOop k = str.klass();
 //   switch (str.change_type()) {
 objArrayOop _ti_base;    // i.e., transitive_interfaces
 int         _ti_index;
 int         _ti_limit;
 // start at the beginning:
-void start() {
+void start();
-klassOop new_type = _changes.new_type();
-_change_type = (new_type == NULL ? NO_CHANGE: Start_Klass);
-_klass = new_type;
-_ti_base = NULL;
-_ti_index = 0;
-_ti_limit = 0;
-}
 public:
 ContextStream(DepChange& changes)
 : _changes(changes)
 { start(); }
 ChangeType change_type()     { return _change_type; }
 klassOop   klass()           { return _klass; }
 };
 friend class DepChange::ContextStream;
-void print();
 };
+// A class hierarchy change coming through the VM (under the Compile_lock).
+// The change is structured as a single new type with any number of supers
+// and implemented interface types.  Other than the new type, any of the
+// super types can be context types for a relevant dependency, which the
+// new type could invalidate.
+class KlassDepChange : public DepChange {
+private:
+// each change set is rooted in exactly one new type (at present):
+KlassHandle _new_type;
+void initialize();
+public:
+// notes the new type, marks it and all its super-types
+KlassDepChange(KlassHandle new_type)
+: _new_type(new_type)
+{
+initialize();
+}
+// cleans up the marks
+~KlassDepChange();
+// What kind of DepChange is this?
+virtual bool is_klass_change() const { return true; }
+klassOop new_type() { return _new_type(); }
+// involves_context(k) is true if k is new_type or any of the super types
+bool involves_context(klassOop k);
+};
+// A CallSite has changed its target.
+class CallSiteDepChange : public DepChange {
+private:
+Handle _call_site;
+Handle _method_handle;
+public:
+CallSiteDepChange(Handle call_site, Handle method_handle)
+: _call_site(call_site),
+_method_handle(method_handle)
+{
+assert(_call_site()    ->is_a(SystemDictionary::CallSite_klass()),     "must be");
+assert(_method_handle()->is_a(SystemDictionary::MethodHandle_klass()), "must be");
+}
+// What kind of DepChange is this?
+virtual bool is_call_site_change() const { return true; }
+oop call_site()     const { return _call_site();     }
+oop method_handle() const { return _method_handle(); }
+};
 #endif // SHARE_VM_CODE_DEPENDENCIES_HPP

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/code/dependencies.hpp @ 3852:fdb992d83a87