1 /*
   2  * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "classfile/javaClasses.hpp"
  27 #include "jfr/leakprofiler/chains/edge.hpp"
  28 #include "jfr/leakprofiler/chains/edgeStore.hpp"
  29 #include "jfr/leakprofiler/chains/edgeUtils.hpp"
  30 #include "jfr/leakprofiler/utilities/unifiedOop.hpp"
  31 #include "oops/fieldStreams.hpp"
  32 #include "oops/instanceKlass.hpp"
  33 #include "oops/objArrayOop.hpp"
  34 #include "oops/oopsHierarchy.hpp"
  35 #include "runtime/handles.inline.hpp"
  36 
  37 bool EdgeUtils::is_leak_edge(const Edge& edge) {
  38   return (const Edge*)edge.pointee()->mark() == &edge;
  39 }
  40 
  41 static int field_offset(const StoredEdge& edge) {
  42   assert(!edge.is_root(), "invariant");
  43   const oop ref_owner = edge.reference_owner();
  44   assert(ref_owner != NULL, "invariant");
  45   const oop* reference = UnifiedOop::decode(edge.reference());
  46   assert(reference != NULL, "invariant");
  47   assert(!UnifiedOop::is_narrow(reference), "invariant");
  48   assert(!ref_owner->is_array(), "invariant");
  49   assert(ref_owner->is_instance(), "invariant");
  50   const int offset = (int)pointer_delta(reference, ref_owner, sizeof(char));
  51   assert(offset < (ref_owner->size() * HeapWordSize), "invariant");
  52   return offset;
  53 }
  54 
  55 static const InstanceKlass* field_type(const StoredEdge& edge) {
  56   assert(!edge.is_root() || !EdgeUtils::is_array_element(edge), "invariant");
  57   return (const InstanceKlass*)edge.reference_owner_klass();
  58 }
  59 
  60 const Symbol* EdgeUtils::field_name_symbol(const Edge& edge) {
  61   assert(!edge.is_root(), "invariant");
  62   assert(!is_array_element(edge), "invariant");
  63   const int offset = field_offset(edge);
  64   const InstanceKlass* ik = field_type(edge);
  65   while (ik != NULL) {
  66     JavaFieldStream jfs(ik);
  67     while (!jfs.done()) {
  68       if (offset == jfs.offset()) {
  69         return jfs.name();
  70       }
  71       jfs.next();
  72     }
  73     ik = (InstanceKlass*)ik->super();
  74   }
  75   return NULL;
  76 }
  77 
  78 jshort EdgeUtils::field_modifiers(const Edge& edge) {
  79   const int offset = field_offset(edge);
  80   const InstanceKlass* ik = field_type(edge);
  81 
  82   while (ik != NULL) {
  83     JavaFieldStream jfs(ik);
  84     while (!jfs.done()) {
  85       if (offset == jfs.offset()) {
  86         return jfs.access_flags().as_short();
  87       }
  88       jfs.next();
  89     }
  90     ik = (InstanceKlass*)ik->super();
  91   }
  92   return 0;
  93 }
  94 
  95 bool EdgeUtils::is_array_element(const Edge& edge) {
  96   assert(!edge.is_root(), "invariant");
  97   const oop ref_owner = edge.reference_owner();
  98   assert(ref_owner != NULL, "invariant");
  99   return ref_owner->is_objArray();
 100 }
 101 
 102 static int array_offset(const Edge& edge) {
 103   assert(!edge.is_root(), "invariant");
 104   const oop ref_owner = edge.reference_owner();
 105   assert(ref_owner != NULL, "invariant");
 106   const oop* reference = UnifiedOop::decode(edge.reference());
 107   assert(reference != NULL, "invariant");
 108   assert(!UnifiedOop::is_narrow(reference), "invariant");
 109   assert(ref_owner->is_array(), "invariant");
 110   const objArrayOop ref_owner_array = static_cast<const objArrayOop>(ref_owner);
 111   const int offset = (int)pointer_delta(reference, ref_owner_array->base(), heapOopSize);
 112   assert(offset >= 0 && offset < ref_owner_array->length(), "invariant");
 113   return offset;
 114 }
 115 
 116 int EdgeUtils::array_index(const Edge& edge) {
 117   return is_array_element(edge) ? array_offset(edge) : 0;
 118 }
 119 
 120 int EdgeUtils::array_size(const Edge& edge) {
 121   if (is_array_element(edge)) {
 122     const oop ref_owner = edge.reference_owner();
 123     assert(ref_owner != NULL, "invariant");
 124     assert(ref_owner->is_objArray(), "invariant");
 125     return ((objArrayOop)(ref_owner))->length();
 126   }
 127   return 0;
 128 }
 129 
 130 const Edge* EdgeUtils::root(const Edge& edge) {
 131   const Edge* current = &edge;
 132   const Edge* parent = current->parent();
 133   while (parent != NULL) {
 134     current = parent;
 135     parent = current->parent();
 136   }
 137   assert(current != NULL, "invariant");
 138   return current;
 139 }
 140 
 141 const Edge* EdgeUtils::ancestor(const Edge& edge, size_t distance) {
 142   const Edge* current = &edge;
 143   const Edge* parent = current->parent();
 144   size_t seek = 0;
 145   while (parent != NULL && seek != distance) {
 146     seek++;
 147     current = parent;
 148     parent = parent->parent();
 149   }
 150   return current;
 151 }