Mercurial > hg > graal-compiler
annotate src/share/vm/runtime/reflectionUtils.hpp @ 10241:d17700c82d7d
8006088: Incompatible heap size flags accepted by VM
Summary: Make processing of minimum, initial and maximum heap size more intiutive by removing previous limitations on allowed values, and make error reporting consistent. Further, fix errors in ergonomic heap sizing.
Reviewed-by: johnc, jwilhelm, tamao
| author | tschatzl |
|---|---|
| date | Mon, 06 May 2013 17:19:42 +0200 |
| parents | 5a9fa2ba85f0 |
| children | f9be75d21404 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 10135 | 2 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP |
| 26 #define SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
| 29 #include "oops/instanceKlass.hpp" | |
| 30 #include "oops/objArrayOop.hpp" | |
| 31 #include "oops/oopsHierarchy.hpp" | |
| 32 #include "runtime/handles.inline.hpp" | |
| 33 #include "runtime/reflection.hpp" | |
| 34 #include "utilities/accessFlags.hpp" | |
| 35 #include "utilities/globalDefinitions.hpp" | |
| 36 | |
| 0 | 37 // A KlassStream is an abstract stream for streaming over self, superclasses |
| 38 // and (super)interfaces. Streaming is done in reverse order (subclasses first, | |
| 39 // interfaces last). | |
| 40 // | |
| 41 // for (KlassStream st(k, false, false); !st.eos(); st.next()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
42 // Klass* k = st.klass(); |
| 0 | 43 // ... |
| 44 // } | |
| 45 | |
| 46 class KlassStream VALUE_OBJ_CLASS_SPEC { | |
| 47 protected: | |
| 48 instanceKlassHandle _klass; // current klass/interface iterated over | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
49 Array<Klass*>* _interfaces; // transitive interfaces for initial class |
| 0 | 50 int _interface_index; // current interface being processed |
| 51 bool _local_only; // process initial class/interface only | |
| 52 bool _classes_only; // process classes only (no interfaces) | |
| 53 int _index; | |
| 54 | |
| 55 virtual int length() const = 0; | |
| 56 | |
| 57 public: | |
| 58 // constructor | |
| 59 KlassStream(instanceKlassHandle klass, bool local_only, bool classes_only); | |
| 60 | |
| 61 // testing | |
| 62 bool eos(); | |
| 63 | |
| 64 // iterating | |
| 65 virtual void next() = 0; | |
| 66 | |
| 67 // accessors | |
| 68 instanceKlassHandle klass() const { return _klass; } | |
| 69 int index() const { return _index; } | |
| 70 }; | |
| 71 | |
| 72 | |
| 73 // A MethodStream streams over all methods in a class, superclasses and (super)interfaces. | |
| 74 // Streaming is done in reverse order (subclasses first, methods in reverse order) | |
| 75 // Usage: | |
| 76 // | |
| 77 // for (MethodStream st(k, false, false); !st.eos(); st.next()) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
78 // Method* m = st.method(); |
| 0 | 79 // ... |
| 80 // } | |
| 81 | |
| 82 class MethodStream : public KlassStream { | |
| 83 private: | |
| 84 int length() const { return methods()->length(); } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
85 Array<Method*>* methods() const { return _klass->methods(); } |
| 0 | 86 public: |
| 87 MethodStream(instanceKlassHandle klass, bool local_only, bool classes_only) | |
| 88 : KlassStream(klass, local_only, classes_only) { | |
| 89 _index = length(); | |
| 90 next(); | |
| 91 } | |
| 92 | |
| 93 void next() { _index--; } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
94 Method* method() const { return methods()->at(index()); } |
| 0 | 95 }; |
| 96 | |
| 97 | |
| 98 // A FieldStream streams over all fields in a class, superclasses and (super)interfaces. | |
| 99 // Streaming is done in reverse order (subclasses first, fields in reverse order) | |
| 100 // Usage: | |
| 101 // | |
| 102 // for (FieldStream st(k, false, false); !st.eos(); st.next()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
103 // Symbol* field_name = st.name(); |
| 0 | 104 // ... |
| 105 // } | |
| 106 | |
| 107 | |
| 108 class FieldStream : public KlassStream { | |
| 109 private: | |
| 3938 | 110 int length() const { return _klass->java_fields_count(); } |
| 111 | |
| 0 | 112 public: |
| 113 FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only) | |
| 114 : KlassStream(klass, local_only, classes_only) { | |
| 115 _index = length(); | |
| 116 next(); | |
| 117 } | |
| 118 | |
| 3938 | 119 void next() { _index -= 1; } |
| 0 | 120 |
| 121 // Accessors for current field | |
| 122 AccessFlags access_flags() const { | |
| 123 AccessFlags flags; | |
| 3938 | 124 flags.set_flags(_klass->field_access_flags(_index)); |
| 0 | 125 return flags; |
| 126 } | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
127 Symbol* name() const { |
| 3938 | 128 return _klass->field_name(_index); |
| 0 | 129 } |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
130 Symbol* signature() const { |
| 3938 | 131 return _klass->field_signature(_index); |
| 0 | 132 } |
| 133 // missing: initval() | |
| 134 int offset() const { | |
| 3938 | 135 return _klass->field_offset( index() ); |
| 0 | 136 } |
| 137 }; | |
| 138 | |
| 10135 | 139 class FilteredField { |
| 0 | 140 private: |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
141 Klass* _klass; |
| 10135 | 142 int _field_offset; |
| 0 | 143 |
| 144 public: | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
145 FilteredField(Klass* klass, int field_offset) { |
| 0 | 146 _klass = klass; |
| 147 _field_offset = field_offset; | |
| 148 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
149 Klass* klass() { return _klass; } |
| 0 | 150 int field_offset() { return _field_offset; } |
| 151 }; | |
| 152 | |
| 153 class FilteredFieldsMap : AllStatic { | |
| 154 private: | |
| 155 static GrowableArray<FilteredField *> *_filtered_fields; | |
| 156 public: | |
| 157 static void initialize(); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
158 static bool is_filtered_field(Klass* klass, int field_offset) { |
| 0 | 159 for (int i=0; i < _filtered_fields->length(); i++) { |
| 160 if (klass == _filtered_fields->at(i)->klass() && | |
| 161 field_offset == _filtered_fields->at(i)->field_offset()) { | |
| 162 return true; | |
| 163 } | |
| 164 } | |
| 165 return false; | |
| 166 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
167 static int filtered_fields_count(Klass* klass, bool local_only) { |
| 0 | 168 int nflds = 0; |
| 169 for (int i=0; i < _filtered_fields->length(); i++) { | |
| 170 if (local_only && klass == _filtered_fields->at(i)->klass()) { | |
| 171 nflds++; | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
172 } else if (klass->is_subtype_of(_filtered_fields->at(i)->klass())) { |
| 0 | 173 nflds++; |
| 174 } | |
| 175 } | |
| 176 return nflds; | |
| 177 } | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
178 // Enhance Class Redefinition Support |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
179 static void classes_do(KlassClosure* f) { |
| 0 | 180 for (int i = 0; i < _filtered_fields->length(); i++) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
181 f->do_klass(_filtered_fields->at(i)->klass()); |
| 0 | 182 } |
| 183 } | |
| 184 }; | |
| 185 | |
| 186 | |
| 187 // A FilteredFieldStream streams over all fields in a class, superclasses and | |
| 188 // (super)interfaces. Streaming is done in reverse order (subclasses first, | |
| 189 // fields in reverse order) | |
| 190 // | |
| 191 // Usage: | |
| 192 // | |
| 193 // for (FilteredFieldStream st(k, false, false); !st.eos(); st.next()) { | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
194 // Symbol* field_name = st.name(); |
| 0 | 195 // ... |
| 196 // } | |
| 197 | |
| 198 class FilteredFieldStream : public FieldStream { | |
| 199 private: | |
| 200 int _filtered_fields_count; | |
| 201 bool has_filtered_field() { return (_filtered_fields_count > 0); } | |
| 202 | |
| 203 public: | |
| 204 FilteredFieldStream(instanceKlassHandle klass, bool local_only, bool classes_only) | |
| 205 : FieldStream(klass, local_only, classes_only) { | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
206 _filtered_fields_count = FilteredFieldsMap::filtered_fields_count((Klass*)klass(), local_only); |
| 0 | 207 } |
| 208 int field_count(); | |
| 209 void next() { | |
| 3938 | 210 _index -= 1; |
| 0 | 211 if (has_filtered_field()) { |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3938
diff
changeset
|
212 while (_index >=0 && FilteredFieldsMap::is_filtered_field((Klass*)_klass(), offset())) { |
| 3938 | 213 _index -= 1; |
| 0 | 214 } |
| 215 } | |
| 216 } | |
| 217 }; | |
| 1972 | 218 |
| 219 #endif // SHARE_VM_RUNTIME_REFLECTIONUTILS_HPP |