128 clean();
129 list.add(new WeakReference<>(metaspaceObject, queue));
130 if (list.getHead() != metadataRoots) {
131 /*
132 * The list enlarged so update the head.
133 */
134 metadataRoots = list.getHead();
135 }
136 assert isRegistered(metaspaceObject);
137 }
138
139 protected ResolvedJavaType createClass(Class<?> javaClass) {
140 if (javaClass.isPrimitive()) {
141 JavaKind kind = JavaKind.fromJavaClass(javaClass);
142 return new HotSpotResolvedPrimitiveType(kind);
143 } else {
144 return new HotSpotResolvedObjectTypeImpl(javaClass, this);
145 }
146 }
147
148 private final ClassValue<WeakReference<ResolvedJavaType>> resolvedJavaType = new ClassValue<WeakReference<ResolvedJavaType>>() {
149 @Override
150 protected WeakReference<ResolvedJavaType> computeValue(Class<?> type) {
151 return new WeakReference<>(createClass(type));
152 }
153 };
154
155 /**
156 * Gets the JVMCI mirror for a {@link Class} object.
157 *
158 * @return the {@link ResolvedJavaType} corresponding to {@code javaClass}
159 */
160 public ResolvedJavaType fromClass(Class<?> javaClass) {
161 ResolvedJavaType javaType = null;
162 while (javaType == null) {
163 WeakReference<ResolvedJavaType> type = resolvedJavaType.get(javaClass);
164 javaType = type.get();
165 if (javaType == null) {
166 /*
167 * If the referent has become null, clear out the current value
168 * and let computeValue above create a new value. Reload the
169 * value in a loop because in theory the WeakReference referent
170 * can be reclaimed at any point.
171 */
172 resolvedJavaType.remove(javaClass);
173 }
174 }
175 return javaType;
176 }
177
178 /**
179 * A very simple append only chunked list implementation.
180 */
181 static class ChunkedList<T> implements Iterable<T> {
182 private static final int CHUNK_SIZE = 32;
183
184 private static final int NEXT_CHUNK_INDEX = CHUNK_SIZE - 1;
185
186 private Object[] head;
187 private int index;
188 private int size;
189
190 ChunkedList() {
|
128 clean();
129 list.add(new WeakReference<>(metaspaceObject, queue));
130 if (list.getHead() != metadataRoots) {
131 /*
132 * The list enlarged so update the head.
133 */
134 metadataRoots = list.getHead();
135 }
136 assert isRegistered(metaspaceObject);
137 }
138
139 protected ResolvedJavaType createClass(Class<?> javaClass) {
140 if (javaClass.isPrimitive()) {
141 JavaKind kind = JavaKind.fromJavaClass(javaClass);
142 return new HotSpotResolvedPrimitiveType(kind);
143 } else {
144 return new HotSpotResolvedObjectTypeImpl(javaClass, this);
145 }
146 }
147
148 private final ClassValue<WeakReference<ResolvedJavaType>> resolvedJavaType = new ClassValue<>() {
149 @Override
150 protected WeakReference<ResolvedJavaType> computeValue(Class<?> type) {
151 return new WeakReference<>(createClass(type));
152 }
153 };
154
155 /**
156 * Gets the JVMCI mirror for a {@link Class} object.
157 *
158 * @return the {@link ResolvedJavaType} corresponding to {@code javaClass}
159 */
160 public ResolvedJavaType fromClass(Class<?> javaClass) {
161 ResolvedJavaType javaType = null;
162 while (javaType == null) {
163 WeakReference<ResolvedJavaType> type = resolvedJavaType.get(javaClass);
164 javaType = type.get();
165 if (javaType == null) {
166 /*
167 * If the referent has become null, clear out the current value and let computeValue
168 * above create a new value. Reload the value in a loop because in theory the
169 * WeakReference referent can be reclaimed at any point.
170 */
171 resolvedJavaType.remove(javaClass);
172 }
173 }
174 return javaType;
175 }
176
177 /**
178 * A very simple append only chunked list implementation.
179 */
180 static class ChunkedList<T> implements Iterable<T> {
181 private static final int CHUNK_SIZE = 32;
182
183 private static final int NEXT_CHUNK_INDEX = CHUNK_SIZE - 1;
184
185 private Object[] head;
186 private int index;
187 private int size;
188
189 ChunkedList() {
|