jdk-sandbox: comparison src/hotspot/share/prims/jvmtiTagMap.cpp

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #include "runtime/vmOperations.hpp"
 #include "utilities/macros.hpp"
 #if INCLUDE_ZGC
 #include "gc/z/zGlobals.hpp"
 #endif
-#if INCLUDE_JVMCI
-#include "jvmci/jvmci.hpp"
-#endif
 // JvmtiTagHashmapEntry
 //
 // Each entry encapsulates a reference to the tagged object
 // and the tag value. In addition an entry includes a next pointer which
 assert(tag != 0, "can't be zero");
 _tag = tag;
 }
 inline bool equals(oop object) {
-return oopDesc::equals(object, object_peek());
+return object == object_peek();
 }
 inline JvmtiTagHashmapEntry* next() const        { return _next; }
 inline void set_next(JvmtiTagHashmapEntry* next) { _next = next; }
 };
 tag_map = ((JvmtiEnvBase*)env)->tag_map();
 if (tag_map == NULL) {
 tag_map = new JvmtiTagMap(env);
 }
 } else {
-CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
+DEBUG_ONLY(Thread::current()->check_possible_safepoint());
 }
 return tag_map;
 }
 // iterate over all entries in the tag map.
 // The reference in this tag map could be the only (implicitly weak)
 // reference to that object. If we hand it out, we need to keep it live wrt
 // SATB marking similar to other j.l.ref.Reference referents. This is
 // achieved by using a phantom load in the object() accessor.
 oop o = entry->object();
-assert(o != NULL && Universe::heap()->is_in_reserved(o), "sanity check");
+assert(o != NULL && Universe::heap()->is_in(o), "sanity check");
 jobject ref = JNIHandles::make_local(JavaThread::current(), o);
 _object_results->append(ref);
 _tag_results->append((uint64_t)entry->tag());
 }
 }
 // An ObjectClosure used to restore the mark bits of an object
 class RestoreMarksClosure : public ObjectClosure {
 public:
 void do_object(oop o) {
 if (o != NULL) {
-markOop mark = o->mark();
+markWord mark = o->mark();
-if (mark->is_marked()) {
+if (mark.is_marked()) {
 o->init_mark();
 }
 }
 }
 };
 // ObjectMarker provides the mark and visited functions
 class ObjectMarker : AllStatic {
 private:
 // saved headers
 static GrowableArray<oop>* _saved_oop_stack;
-static GrowableArray<markOop>* _saved_mark_stack;
+static GrowableArray<markWord>* _saved_mark_stack;
 static bool _needs_reset;                  // do we need to reset mark bits?
 public:
 static void init();                       // initialize
 static void done();                       // clean-up
 static inline bool needs_reset()            { return _needs_reset; }
 static inline void set_needs_reset(bool v)  { _needs_reset = v; }
 };
 GrowableArray<oop>* ObjectMarker::_saved_oop_stack = NULL;
-GrowableArray<markOop>* ObjectMarker::_saved_mark_stack = NULL;
+GrowableArray<markWord>* ObjectMarker::_saved_mark_stack = NULL;
 bool ObjectMarker::_needs_reset = true;  // need to reset mark bits by default
 // initialize ObjectMarker - prepares for object marking
 void ObjectMarker::init() {
 assert(Thread::current()->is_VM_thread(), "must be VMThread");
 // prepare heap for iteration
 Universe::heap()->ensure_parsability(false);  // no need to retire TLABs
 // create stacks for interesting headers
-_saved_mark_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<markOop>(4000, true);
+_saved_mark_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<markWord>(4000, true);
 _saved_oop_stack = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<oop>(4000, true);
 if (UseBiasedLocking) {
 BiasedLocking::preserve_marks();
 }
 }
 // now restore the interesting headers
 for (int i = 0; i < _saved_oop_stack->length(); i++) {
 oop o = _saved_oop_stack->at(i);
-markOop mark = _saved_mark_stack->at(i);
+markWord mark = _saved_mark_stack->at(i);
 o->set_mark(mark);
 }
 if (UseBiasedLocking) {
 BiasedLocking::restore_marks();
 }
 // mark an object
 inline void ObjectMarker::mark(oop o) {
 assert(Universe::heap()->is_in(o), "sanity check");
-assert(!o->mark()->is_marked(), "should only mark an object once");
+assert(!o->mark().is_marked(), "should only mark an object once");
 // object's mark word
-markOop mark = o->mark();
+markWord mark = o->mark();
-if (mark->must_be_preserved(o)) {
+if (o->mark_must_be_preserved(mark)) {
 _saved_mark_stack->push(mark);
 _saved_oop_stack->push(o);
 }
 // mark the object
-o->set_mark(markOopDesc::prototype()->set_marked());
+o->set_mark(markWord::prototype().set_marked());
 }
 // return true if object is marked
 inline bool ObjectMarker::visited(oop o) {
-return o->mark()->is_marked();
+return o->mark().is_marked();
 }
 // Stack allocated class to help ensure that ObjectMarker is used
 // correctly. Constructor initializes ObjectMarker, destructor calls
 // ObjectMarker's done() function to restore object headers.
 // ignore null
 if (o == NULL) {
 return;
 }
-assert(Universe::heap()->is_in_reserved(o), "should be impossible");
+assert(Universe::heap()->is_in(o), "should be impossible");
 jvmtiHeapReferenceKind kind = root_kind();
 if (kind == JVMTI_HEAP_REFERENCE_SYSTEM_CLASS) {
 // SystemDictionary::oops_do reports the application
 // class loader as a root. We want this root to be reported as
 char type = field->field_type();
 if (!is_primitive_field_type(type)) {
 oop fld_o = o->obj_field(field->field_offset());
 // ignore any objects that aren't visible to profiler
 if (fld_o != NULL) {
-assert(Universe::heap()->is_in_reserved(fld_o), "unsafe code should not "
+assert(Universe::heap()->is_in(fld_o), "unsafe code should not "
 "have references to Klass* anymore");
 int slot = field->field_index();
 if (!CallbackInvoker::report_field_reference(o, fld_o, slot)) {
 return false;
 }
 blk.set_kind(JVMTI_HEAP_REFERENCE_OTHER);
 Universe::oops_do(&blk);
 if (blk.stopped()) {
 return false;
 }
-#if INCLUDE_JVMCI
-blk.set_kind(JVMTI_HEAP_REFERENCE_OTHER);
-JVMCI::oops_do(&blk);
-if (blk.stopped()) {
-return false;
-}
-#endif
 return true;
 }
 // Walk the stack of a given thread and find all references (locals

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 54786	ebf733a324d4
child 58679	9c3209ff7550