graal-compiler: src/share/vm/code/dependencies.cpp comparison

comparison src/share/vm/code/dependencies.cpp @ 7094:eec7173947a1

removed remaining use of the C++ "compiler interface" (i.e. ci) by Graal for installing dependencies

author	Doug Simon <doug.simon@oracle.com>
date	Thu, 29 Nov 2012 17:13:13 +0100
parents	80e866b1d053
children	0778b04fc682

comparison

equal deleted inserted replaced

-:dff79b1f82f1
+:eec7173947a1
 void Dependencies::initialize(ciEnv* env) {
 Arena* arena = env->arena();
 _oop_recorder = env->oop_recorder();
 _log = env->log();
 _dep_seen = new(arena) GrowableArray<int>(arena, 500, 0, 0);
+#ifdef GRAAL
+_using_dep_values = false;
+#endif // GRAAL
 DEBUG_ONLY(_deps[end_marker] = NULL);
 for (int i = (int)FIRST_TYPE; i < (int)TYPE_LIMIT; i++) {
 _deps[i] = new(arena) GrowableArray<ciBaseObject*>(arena, 10, 0, 0);
 }
 _content_bytes = NULL;
 void Dependencies::assert_call_site_target_value(ciCallSite* call_site, ciMethodHandle* method_handle) {
 check_ctxk(call_site->klass());
 assert_common_2(call_site_target_value, call_site, method_handle);
 }
+#ifdef GRAAL
+Dependencies::Dependencies(Arena* arena, OopRecorder* oop_recorder) {
+_oop_recorder = oop_recorder;
+_log = NULL;
+_dep_seen = new(arena) GrowableArray<int>(arena, 500, 0, 0);
+_using_dep_values = true;
+DEBUG_ONLY(_dep_values[end_marker] = NULL);
+for (int i = (int)FIRST_TYPE; i < (int)TYPE_LIMIT; i++) {
+_dep_values[i] = new(arena) GrowableArray<DepValue>(arena, 10, 0, DepValue());
+}
+_content_bytes = NULL;
+_size_in_bytes = (size_t)-1;
+assert(TYPE_LIMIT <= (1<<LG2_TYPE_LIMIT), "sanity");
+}
+void Dependencies::assert_evol_method(DepValue m) {
+assert_common_1(evol_method, m);
+}
+void Dependencies::assert_leaf_type(DepValue ctxk_dv) {
+Klass* ctxk = ctxk_dv.as_klass();
+if (ctxk->oop_is_array()) {
+// As a special case, support this assertion on an array type,
+// which reduces to an assertion on its element type.
+// Note that this cannot be done with assertions that
+// relate to concreteness or abstractness.
+BasicType elemt = ArrayKlass::cast(ctxk)->element_type();
+if (is_java_primitive(elemt))  return;   // Ex:  int[][]
+ctxk = ObjArrayKlass::cast(ctxk)->bottom_klass();
+//if (ctxk->is_final())  return;            // Ex:  String[][]
+}
+check_ctxk(ctxk);
+assert_common_1(leaf_type, ctxk_dv);
+}
+void Dependencies::assert_abstract_with_unique_concrete_subtype(DepValue ctxk, DepValue conck) {
+check_ctxk_abstract(ctxk.as_klass());
+assert_common_2(abstract_with_unique_concrete_subtype, ctxk, conck);
+}
+void Dependencies::assert_unique_concrete_method(DepValue ctxk, DepValue uniqm) {
+check_ctxk(ctxk.as_klass());
+assert_common_2(unique_concrete_method, ctxk, uniqm);
+}
+#endif // GRAAL
 // Helper function.  If we are adding a new dep. under ctxk2,
 // try to find an old dep. under a broader* ctxk1.  If there is
 //
 bool Dependencies::maybe_merge_ctxk(GrowableArray<ciBaseObject*>* deps,
 deps->append(ctxk);
 deps->append(x);
 deps->append(x2);
 }
+#ifdef GRAAL
+bool Dependencies::maybe_merge_ctxk(GrowableArray<DepValue>* deps,
+int ctxk_i, DepValue ctxk2_dv) {
+Klass* ctxk1 = deps->at(ctxk_i).as_klass();
+Klass* ctxk2 = ctxk2_dv.as_klass();
+if (ctxk2->is_subtype_of(ctxk1)) {
+return true;  // success, and no need to change
+} else if (ctxk1->is_subtype_of(ctxk2)) {
+// new context class fully subsumes previous one
+deps->at_put(ctxk_i, ctxk2_dv);
+return true;
+} else {
+return false;
+}
+}
+void Dependencies::assert_common_1(DepType dept, DepValue x) {
+assert(dep_args(dept) == 1, "sanity");
+//log_dependency(dept, x);
+GrowableArray<DepValue>* deps = _dep_values[dept];
+// see if the same (or a similar) dep is already recorded
+if (note_dep_seen(dept, x)) {
+assert(deps->find(x) >= 0, "sanity");
+} else {
+deps->append(x);
+}
+}
+void Dependencies::assert_common_2(DepType dept,
+DepValue x0, DepValue x1) {
+assert(dep_args(dept) == 2, "sanity");
+//log_dependency(dept, x0, x1);
+GrowableArray<DepValue>* deps = _dep_values[dept];
+// see if the same (or a similar) dep is already recorded
+bool has_ctxk = has_explicit_context_arg(dept);
+if (has_ctxk) {
+assert(dep_context_arg(dept) == 0, "sanity");
+if (note_dep_seen(dept, x1)) {
+// look in this bucket for redundant assertions
+const int stride = 2;
+for (int i = deps->length(); (i -= stride) >= 0; ) {
+DepValue y1 = deps->at(i+1);
+if (x1 == y1) {  // same subject; check the context
+if (maybe_merge_ctxk(deps, i+0, x0)) {
+return;
+}
+}
+}
+}
+} else {
+assert(dep_implicit_context_arg(dept) == 0, "sanity");
+if (note_dep_seen(dept, x0) && note_dep_seen(dept, x1)) {
+// look in this bucket for redundant assertions
+const int stride = 2;
+for (int i = deps->length(); (i -= stride) >= 0; ) {
+DepValue y0 = deps->at(i+0);
+DepValue y1 = deps->at(i+1);
+if (x0 == y0 && x1 == y1) {
+return;
+}
+}
+}
+}
+// append the assertion in the correct bucket:
+deps->append(x0);
+deps->append(x1);
+}
+#endif // GRAAL
 /// Support for encoding dependencies into an nmethod:
 void Dependencies::copy_to(nmethod* nm) {
 address beg = nm->dependencies_begin();
 address end = nm->dependencies_end();
 static int sort_dep_arg_2(ciBaseObject** p1, ciBaseObject** p2)
 { return sort_dep(p1, p2, 2); }
 static int sort_dep_arg_3(ciBaseObject** p1, ciBaseObject** p2)
 { return sort_dep(p1, p2, 3); }
+#ifdef GRAAL
+// metadata deps are sorted before object deps
+static int sort_dep_value(DepValue* p1, DepValue* p2, int narg) {
+for (int i = 0; i < narg; i++) {
+int diff = p1[i].sort_key() - p2[i].sort_key();
+if (diff != 0)  return diff;
+}
+return 0;
+}
+static int sort_dep_value_arg_1(DepValue* p1, DepValue* p2)
+{ return sort_dep_value(p1, p2, 1); }
+static int sort_dep_value_arg_2(DepValue* p1, DepValue* p2)
+{ return sort_dep_value(p1, p2, 2); }
+static int sort_dep_value_arg_3(DepValue* p1, DepValue* p2)
+{ return sort_dep_value(p1, p2, 3); }
+#endif // GRAAL
 void Dependencies::sort_all_deps() {
+#ifdef GRAAL
+if (_using_dep_values) {
+for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) {
+DepType dept = (DepType)deptv;
+GrowableArray<DepValue>* deps = _dep_values[dept];
+if (deps->length() <= 1)  continue;
+switch (dep_args(dept)) {
+case 1: deps->sort(sort_dep_value_arg_1, 1); break;
+case 2: deps->sort(sort_dep_value_arg_2, 2); break;
+case 3: deps->sort(sort_dep_value_arg_3, 3); break;
+default: ShouldNotReachHere();
+}
+}
+return;
+}
+#endif // GRAAL
 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) {
 DepType dept = (DepType)deptv;
 GrowableArray<ciBaseObject*>* deps = _deps[dept];
 if (deps->length() <= 1)  continue;
 switch (dep_args(dept)) {
 }
 }
 size_t Dependencies::estimate_size_in_bytes() {
 size_t est_size = 100;
+#ifdef GRAAL
+if (_using_dep_values) {
+for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) {
+DepType dept = (DepType)deptv;
+GrowableArray<DepValue>* deps = _dep_values[dept];
+est_size += deps->length() * 2;  // tags and argument(s)
+}
+return est_size;
+}
+#endif // GRAAL
 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) {
 DepType dept = (DepType)deptv;
 GrowableArray<ciBaseObject*>* deps = _deps[dept];
 est_size += deps->length()*2;  // tags and argument(s)
 }
 sort_all_deps();
 // cast is safe, no deps can overflow INT_MAX
 CompressedWriteStream bytes((int)estimate_size_in_bytes());
+#ifdef GRAAL
+if (_using_dep_values) {
+for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) {
+DepType dept = (DepType)deptv;
+GrowableArray<DepValue>* deps = _dep_values[dept];
+if (deps->length() == 0)  continue;
+int stride = dep_args(dept);
+int ctxkj  = dep_context_arg(dept);  // -1 if no context arg
+assert(stride > 0, "sanity");
+for (int i = 0; i < deps->length(); i += stride) {
+jbyte code_byte = (jbyte)dept;
+int skipj = -1;
+if (ctxkj >= 0 && ctxkj+1 < stride) {
+Klass*  ctxk = deps->at(i+ctxkj+0).as_klass();
+DepValue x     = deps->at(i+ctxkj+1);  // following argument
+if (ctxk == ctxk_encoded_as_null(dept, x.as_metadata())) {
+skipj = ctxkj;  // we win:  maybe one less oop to keep track of
+code_byte |= default_context_type_bit;
+}
+}
+bytes.write_byte(code_byte);
+for (int j = 0; j < stride; j++) {
+if (j == skipj)  continue;
+DepValue v = deps->at(i+j);
+int idx = v.index();
+bytes.write_int(idx);
+}
+}
+}
+} else {
+#endif // GRAAL
 for (int deptv = (int)FIRST_TYPE; deptv < (int)TYPE_LIMIT; deptv++) {
 DepType dept = (DepType)deptv;
 GrowableArray<ciBaseObject*>* deps = _deps[dept];
 if (deps->length() == 0)  continue;
 int stride = dep_args(dept);
 }
 bytes.write_int(idx);
 }
 }
 }
+#ifdef GRAAL
+}
+#endif // GRAAL
 // write a sentinel byte to mark the end
 bytes.write_byte(end_marker);
 // round it out to a word boundary
 assert((jbyte)default_context_type_bit != 0, "byte overflow");
 _content_bytes = bytes.buffer();
 _size_in_bytes = bytes.position();
 }
 const char* Dependencies::_dep_name[TYPE_LIMIT] = {
 "end_marker",
 "evol_method",
 "leaf_type",

Mercurial > hg > graal-compiler

comparison src/share/vm/code/dependencies.cpp @ 7094:eec7173947a1