--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hotspot/share/prims/jvmtiCodeBlobEvents.cpp Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2003, 2012, 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.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "code/codeBlob.hpp"
+#include "code/codeCache.hpp"
+#include "code/scopeDesc.hpp"
+#include "code/vtableStubs.hpp"
+#include "memory/resourceArea.hpp"
+#include "oops/oop.inline.hpp"
+#include "prims/jvmtiCodeBlobEvents.hpp"
+#include "prims/jvmtiExport.hpp"
+#include "runtime/handles.hpp"
+#include "runtime/handles.inline.hpp"
+#include "runtime/vmThread.hpp"
+
+// Support class to collect a list of the non-nmethod CodeBlobs in
+// the CodeCache.
+//
+// This class actually creates a list of JvmtiCodeBlobDesc - each JvmtiCodeBlobDesc
+// describes a single CodeBlob in the CodeCache. Note that collection is
+// done to a static list - this is because CodeCache::blobs_do is defined
+// as void CodeCache::blobs_do(void f(CodeBlob* nm)) and hence requires
+// a C or static method.
+//
+// Usage :-
+//
+// CodeBlobCollector collector;
+//
+// collector.collect();
+// JvmtiCodeBlobDesc* blob = collector.first();
+// while (blob != NULL) {
+// :
+// blob = collector.next();
+// }
+//
+
+class CodeBlobCollector : StackObj {
+ private:
+ GrowableArray<JvmtiCodeBlobDesc*>* _code_blobs; // collected blobs
+ int _pos; // iterator position
+
+ // used during a collection
+ static GrowableArray<JvmtiCodeBlobDesc*>* _global_code_blobs;
+ static void do_blob(CodeBlob* cb);
+ static void do_vtable_stub(VtableStub* vs);
+ public:
+ CodeBlobCollector() {
+ _code_blobs = NULL;
+ _pos = -1;
+ }
+ ~CodeBlobCollector() {
+ if (_code_blobs != NULL) {
+ for (int i=0; i<_code_blobs->length(); i++) {
+ FreeHeap(_code_blobs->at(i));
+ }
+ delete _code_blobs;
+ }
+ }
+
+ // collect list of code blobs in the cache
+ void collect();
+
+ // iteration support - return first code blob
+ JvmtiCodeBlobDesc* first() {
+ assert(_code_blobs != NULL, "not collected");
+ if (_code_blobs->length() == 0) {
+ return NULL;
+ }
+ _pos = 0;
+ return _code_blobs->at(0);
+ }
+
+ // iteration support - return next code blob
+ JvmtiCodeBlobDesc* next() {
+ assert(_pos >= 0, "iteration not started");
+ if (_pos+1 >= _code_blobs->length()) {
+ return NULL;
+ }
+ return _code_blobs->at(++_pos);
+ }
+
+};
+
+// used during collection
+GrowableArray<JvmtiCodeBlobDesc*>* CodeBlobCollector::_global_code_blobs;
+
+
+// called for each CodeBlob in the CodeCache
+//
+// This function filters out nmethods as it is only interested in
+// other CodeBlobs. This function also filters out CodeBlobs that have
+// a duplicate starting address as previous blobs. This is needed to
+// handle the case where multiple stubs are generated into a single
+// BufferBlob.
+
+void CodeBlobCollector::do_blob(CodeBlob* cb) {
+
+ // ignore nmethods
+ if (cb->is_nmethod()) {
+ return;
+ }
+ // exclude VtableStubs, which are processed separately
+ if (cb->is_buffer_blob() && strcmp(cb->name(), "vtable chunks") == 0) {
+ return;
+ }
+
+ // check if this starting address has been seen already - the
+ // assumption is that stubs are inserted into the list before the
+ // enclosing BufferBlobs.
+ address addr = cb->code_begin();
+ for (int i=0; i<_global_code_blobs->length(); i++) {
+ JvmtiCodeBlobDesc* scb = _global_code_blobs->at(i);
+ if (addr == scb->code_begin()) {
+ return;
+ }
+ }
+
+ // record the CodeBlob details as a JvmtiCodeBlobDesc
+ JvmtiCodeBlobDesc* scb = new JvmtiCodeBlobDesc(cb->name(), cb->code_begin(), cb->code_end());
+ _global_code_blobs->append(scb);
+}
+
+// called for each VtableStub in VtableStubs
+
+void CodeBlobCollector::do_vtable_stub(VtableStub* vs) {
+ JvmtiCodeBlobDesc* scb = new JvmtiCodeBlobDesc(vs->is_vtable_stub() ? "vtable stub" : "itable stub",
+ vs->code_begin(), vs->code_end());
+ _global_code_blobs->append(scb);
+}
+
+// collects a list of CodeBlobs in the CodeCache.
+//
+// The created list is growable array of JvmtiCodeBlobDesc - each one describes
+// a CodeBlob. Note that the list is static - this is because CodeBlob::blobs_do
+// requires a a C or static function so we can't use an instance function. This
+// isn't a problem as the iteration is serial anyway as we need the CodeCache_lock
+// to iterate over the code cache.
+//
+// Note that the CodeBlobs in the CodeCache will include BufferBlobs that may
+// contain multiple stubs. As a profiler is interested in the stubs rather than
+// the enclosing container we first iterate over the stub code descriptors so
+// that the stubs go into the list first. do_blob will then filter out the
+// enclosing blobs if the starting address of the enclosing blobs matches the
+// starting address of first stub generated in the enclosing blob.
+
+void CodeBlobCollector::collect() {
+ assert_locked_or_safepoint(CodeCache_lock);
+ assert(_global_code_blobs == NULL, "checking");
+
+ // create the global list
+ _global_code_blobs = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JvmtiCodeBlobDesc*>(50,true);
+
+ // iterate over the stub code descriptors and put them in the list first.
+ for (StubCodeDesc* desc = StubCodeDesc::first(); desc != NULL; desc = StubCodeDesc::next(desc)) {
+ _global_code_blobs->append(new JvmtiCodeBlobDesc(desc->name(), desc->begin(), desc->end()));
+ }
+
+ // Vtable stubs are not described with StubCodeDesc,
+ // process them separately
+ VtableStubs::vtable_stub_do(do_vtable_stub);
+
+ // next iterate over all the non-nmethod code blobs and add them to
+ // the list - as noted above this will filter out duplicates and
+ // enclosing blobs.
+ CodeCache::blobs_do(do_blob);
+
+ // make the global list the instance list so that it can be used
+ // for other iterations.
+ _code_blobs = _global_code_blobs;
+ _global_code_blobs = NULL;
+}
+
+
+// Generate a DYNAMIC_CODE_GENERATED event for each non-nmethod code blob.
+
+jvmtiError JvmtiCodeBlobEvents::generate_dynamic_code_events(JvmtiEnv* env) {
+ CodeBlobCollector collector;
+
+ // First collect all the code blobs. This has to be done in a
+ // single pass over the code cache with CodeCache_lock held because
+ // there isn't any safe way to iterate over regular CodeBlobs since
+ // they can be freed at any point.
+ {
+ MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+ collector.collect();
+ }
+
+ // iterate over the collected list and post an event for each blob
+ JvmtiCodeBlobDesc* blob = collector.first();
+ while (blob != NULL) {
+ JvmtiExport::post_dynamic_code_generated(env, blob->name(), blob->code_begin(), blob->code_end());
+ blob = collector.next();
+ }
+ return JVMTI_ERROR_NONE;
+}
+
+
+// Generate a COMPILED_METHOD_LOAD event for each nnmethod
+jvmtiError JvmtiCodeBlobEvents::generate_compiled_method_load_events(JvmtiEnv* env) {
+ HandleMark hm;
+
+ // Walk the CodeCache notifying for live nmethods. The code cache
+ // may be changing while this is happening which is ok since newly
+ // created nmethod will notify normally and nmethods which are freed
+ // can be safely skipped.
+ MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+ // Iterate over non-profiled and profiled nmethods
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* current = iter.method();
+ // Lock the nmethod so it can't be freed
+ nmethodLocker nml(current);
+
+ // Don't hold the lock over the notify or jmethodID creation
+ MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+ current->get_and_cache_jmethod_id();
+ JvmtiExport::post_compiled_method_load(current);
+ }
+ return JVMTI_ERROR_NONE;
+}
+
+
+// create a C-heap allocated address location map for an nmethod
+void JvmtiCodeBlobEvents::build_jvmti_addr_location_map(nmethod *nm,
+ jvmtiAddrLocationMap** map_ptr,
+ jint *map_length_ptr)
+{
+ ResourceMark rm;
+ jvmtiAddrLocationMap* map = NULL;
+ jint map_length = 0;
+
+
+ // Generate line numbers using PcDesc and ScopeDesc info
+ methodHandle mh(nm->method());
+
+ if (!mh->is_native()) {
+ PcDesc *pcd;
+ int pcds_in_method;
+
+ pcds_in_method = (nm->scopes_pcs_end() - nm->scopes_pcs_begin());
+ map = NEW_C_HEAP_ARRAY(jvmtiAddrLocationMap, pcds_in_method, mtInternal);
+
+ address scopes_data = nm->scopes_data_begin();
+ for( pcd = nm->scopes_pcs_begin(); pcd < nm->scopes_pcs_end(); ++pcd ) {
+ ScopeDesc sc0(nm, pcd->scope_decode_offset(), pcd->should_reexecute(), pcd->rethrow_exception(), pcd->return_oop());
+ ScopeDesc *sd = &sc0;
+ while( !sd->is_top() ) { sd = sd->sender(); }
+ int bci = sd->bci();
+ if (bci != InvocationEntryBci) {
+ assert(map_length < pcds_in_method, "checking");
+ map[map_length].start_address = (const void*)pcd->real_pc(nm);
+ map[map_length].location = bci;
+ ++map_length;
+ }
+ }
+ }
+
+ *map_ptr = map;
+ *map_length_ptr = map_length;
+}