1 /* 2 * Copyright (c) 1999, 2005, 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 // A KlassStream is an abstract stream for streaming over self, superclasses 26 // and (super)interfaces. Streaming is done in reverse order (subclasses first, 27 // interfaces last). 28 // 29 // for (KlassStream st(k, false, false); !st.eos(); st.next()) { 30 // klassOop k = st.klass(); 31 // ... 32 // } 33 34 class KlassStream VALUE_OBJ_CLASS_SPEC { 35 protected: 36 instanceKlassHandle _klass; // current klass/interface iterated over 37 objArrayHandle _interfaces; // transitive interfaces for initial class 38 int _interface_index; // current interface being processed 39 bool _local_only; // process initial class/interface only 40 bool _classes_only; // process classes only (no interfaces) 41 int _index; 42 43 virtual int length() const = 0; 44 45 public: 46 // constructor 47 KlassStream(instanceKlassHandle klass, bool local_only, bool classes_only); 48 49 // testing 50 bool eos(); 51 52 // iterating 53 virtual void next() = 0; 54 55 // accessors 56 instanceKlassHandle klass() const { return _klass; } 57 int index() const { return _index; } 58 }; 59 60 61 // A MethodStream streams over all methods in a class, superclasses and (super)interfaces. 62 // Streaming is done in reverse order (subclasses first, methods in reverse order) 63 // Usage: 64 // 65 // for (MethodStream st(k, false, false); !st.eos(); st.next()) { 66 // methodOop m = st.method(); 67 // ... 68 // } 69 70 class MethodStream : public KlassStream { 71 private: 72 int length() const { return methods()->length(); } 73 objArrayOop methods() const { return _klass->methods(); } 74 public: 75 MethodStream(instanceKlassHandle klass, bool local_only, bool classes_only) 76 : KlassStream(klass, local_only, classes_only) { 77 _index = length(); 78 next(); 79 } 80 81 void next() { _index--; } 82 methodOop method() const { return methodOop(methods()->obj_at(index())); } 83 }; 84 85 86 // A FieldStream streams over all fields in a class, superclasses and (super)interfaces. 87 // Streaming is done in reverse order (subclasses first, fields in reverse order) 88 // Usage: 89 // 90 // for (FieldStream st(k, false, false); !st.eos(); st.next()) { 91 // symbolOop field_name = st.name(); 92 // ... 93 // } 94 95 96 class FieldStream : public KlassStream { 97 private: 98 int length() const { return fields()->length(); } 99 constantPoolOop constants() const { return _klass->constants(); } 100 protected: 101 typeArrayOop fields() const { return _klass->fields(); } 102 public: 103 FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only) 104 : KlassStream(klass, local_only, classes_only) { 105 _index = length(); 106 next(); 107 } 108 109 void next() { _index -= instanceKlass::next_offset; } 110 111 // Accessors for current field 112 AccessFlags access_flags() const { 113 AccessFlags flags; 114 flags.set_flags(fields()->ushort_at(index() + instanceKlass::access_flags_offset)); 115 return flags; 116 } 117 symbolOop name() const { 118 int name_index = fields()->ushort_at(index() + instanceKlass::name_index_offset); 119 return constants()->symbol_at(name_index); 120 } 121 symbolOop signature() const { 122 int signature_index = fields()->ushort_at(index() + 123 instanceKlass::signature_index_offset); 124 return constants()->symbol_at(signature_index); 125 } 126 // missing: initval() 127 int offset() const { 128 return _klass->offset_from_fields( index() ); 129 } 130 }; 131 132 class FilteredField { 133 private: 134 klassOop _klass; 135 int _field_offset; 136 137 public: 138 FilteredField(klassOop klass, int field_offset) { 139 _klass = klass; 140 _field_offset = field_offset; 141 } 142 klassOop klass() { return _klass; } 143 oop* klass_addr() { return (oop*) &_klass; } 144 int field_offset() { return _field_offset; } 145 }; 146 147 class FilteredFieldsMap : AllStatic { 148 private: 149 static GrowableArray<FilteredField *> *_filtered_fields; 150 public: 151 static void initialize(); 152 static bool is_filtered_field(klassOop klass, int field_offset) { 153 for (int i=0; i < _filtered_fields->length(); i++) { 154 if (klass == _filtered_fields->at(i)->klass() && 155 field_offset == _filtered_fields->at(i)->field_offset()) { 156 return true; 157 } 158 } 159 return false; 160 } 161 static int filtered_fields_count(klassOop klass, bool local_only) { 162 int nflds = 0; 163 for (int i=0; i < _filtered_fields->length(); i++) { 164 if (local_only && klass == _filtered_fields->at(i)->klass()) { 165 nflds++; 166 } else if (klass->klass_part()->is_subtype_of(_filtered_fields->at(i)->klass())) { 167 nflds++; 168 } 169 } 170 return nflds; 171 } 172 // GC support. 173 static void klasses_oops_do(OopClosure* f) { 174 for (int i = 0; i < _filtered_fields->length(); i++) { 175 f->do_oop((oop*)_filtered_fields->at(i)->klass_addr()); 176 } 177 } 178 }; 179 180 181 // A FilteredFieldStream streams over all fields in a class, superclasses and 182 // (super)interfaces. Streaming is done in reverse order (subclasses first, 183 // fields in reverse order) 184 // 185 // Usage: 186 // 187 // for (FilteredFieldStream st(k, false, false); !st.eos(); st.next()) { 188 // symbolOop field_name = st.name(); 189 // ... 190 // } 191 192 class FilteredFieldStream : public FieldStream { 193 private: 194 int _filtered_fields_count; 195 bool has_filtered_field() { return (_filtered_fields_count > 0); } 196 197 public: 198 FilteredFieldStream(instanceKlassHandle klass, bool local_only, bool classes_only) 199 : FieldStream(klass, local_only, classes_only) { 200 _filtered_fields_count = FilteredFieldsMap::filtered_fields_count((klassOop)klass(), local_only); 201 } 202 int field_count(); 203 void next() { 204 _index -= instanceKlass::next_offset; 205 if (has_filtered_field()) { 206 while (_index >=0 && FilteredFieldsMap::is_filtered_field((klassOop)_klass(), offset())) { 207 _index -= instanceKlass::next_offset; 208 } 209 } 210 } 211 };