1 /*
2 * Copyright (c) 2011, 2015, 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 package jdk.vm.ci.hotspot;
24
25 import static java.util.Objects.requireNonNull;
26
27 import java.lang.annotation.Annotation;
28 import java.lang.reflect.Array;
29 import java.lang.reflect.Modifier;
30 import java.net.URL;
31
32 import jdk.vm.ci.common.JVMCIError;
33 import jdk.vm.ci.meta.Assumptions.AssumptionResult;
34 import jdk.vm.ci.meta.JavaConstant;
35 import jdk.vm.ci.meta.JavaKind;
36 import jdk.vm.ci.meta.JavaType;
37 import jdk.vm.ci.meta.ResolvedJavaField;
38 import jdk.vm.ci.meta.ResolvedJavaMethod;
39 import jdk.vm.ci.meta.ResolvedJavaType;
40
41 /**
42 * Implementation of {@link JavaType} for primitive HotSpot types.
43 */
44 public final class HotSpotResolvedPrimitiveType extends HotSpotResolvedJavaType implements HotSpotProxified {
45
46 private final JavaKind kind;
47
48 /**
49 * Creates the JVMCI mirror for a primitive {@link JavaKind}.
50 *
51 * <p>
52 * <b>NOTE</b>: Creating an instance of this class does not install the mirror for the
53 * {@link Class} type. Use {@link HotSpotJVMCIRuntimeProvider#fromClass(Class)} instead.
54 * </p>
55 *
56 * @param kind the Kind to create the mirror for
57 */
58 public HotSpotResolvedPrimitiveType(JavaKind kind) {
59 super(String.valueOf(Character.toUpperCase(kind.getTypeChar())));
60 this.kind = kind;
61 assert mirror().isPrimitive() : mirror() + " not a primitive type";
62 }
63
64 @Override
65 public int getModifiers() {
66 return Modifier.ABSTRACT | Modifier.FINAL | Modifier.PUBLIC;
67 }
68
69 @Override
70 public HotSpotResolvedObjectTypeImpl getArrayClass() {
71 if (kind == JavaKind.Void) {
72 return null;
73 }
74 Class<?> javaArrayMirror = Array.newInstance(mirror(), 0).getClass();
75 return HotSpotResolvedObjectTypeImpl.fromObjectClass(javaArrayMirror);
76 }
77
78 public ResolvedJavaType getElementalType() {
79 return this;
80 }
81
82 @Override
83 public ResolvedJavaType getComponentType() {
84 return null;
85 }
86
87 @Override
88 public ResolvedJavaType asExactType() {
89 return this;
90 }
91
92 @Override
93 public ResolvedJavaType getSuperclass() {
94 return null;
95 }
96
97 @Override
98 public ResolvedJavaType[] getInterfaces() {
99 return new ResolvedJavaType[0];
100 }
101
102 @Override
103 public ResolvedJavaType getSingleImplementor() {
104 throw new JVMCIError("Cannot call getSingleImplementor() on a non-interface type: %s", this);
105 }
106
107 @Override
108 public ResolvedJavaType findLeastCommonAncestor(ResolvedJavaType otherType) {
109 return null;
110 }
111
112 @Override
113 public JavaConstant getObjectHub() {
114 throw JVMCIError.unimplemented();
115 }
116
117 @Override
118 public JavaConstant getJavaClass() {
119 throw JVMCIError.unimplemented();
120 }
121
122 @Override
123 public AssumptionResult<Boolean> hasFinalizableSubclass() {
124 return new AssumptionResult<>(false);
125 }
126
127 @Override
128 public boolean hasFinalizer() {
129 return false;
130 }
131
132 @Override
133 public boolean isArray() {
134 return false;
135 }
136
137 @Override
138 public boolean isPrimitive() {
139 return true;
140 }
141
142 @Override
143 public boolean isInitialized() {
144 return true;
145 }
146
147 public boolean isLinked() {
148 return true;
149 }
150
151 @Override
152 public boolean isInstance(JavaConstant obj) {
153 return false;
154 }
155
156 @Override
157 public boolean isInstanceClass() {
158 return false;
159 }
160
161 @Override
162 public boolean isInterface() {
163 return false;
164 }
165
166 @Override
167 public boolean isAssignableFrom(ResolvedJavaType other) {
168 assert other != null;
169 return other.equals(this);
170 }
171
172 @Override
173 public JavaKind getJavaKind() {
174 return kind;
175 }
176
177 @Override
178 public boolean isJavaLangObject() {
179 return false;
180 }
181
182 @Override
183 public ResolvedJavaMethod resolveConcreteMethod(ResolvedJavaMethod method, ResolvedJavaType callerType) {
184 return null;
185 }
186
187 @Override
188 public ResolvedJavaMethod resolveMethod(ResolvedJavaMethod method, ResolvedJavaType callerType) {
189 return null;
190 }
191
192 @Override
193 public String toString() {
194 return "HotSpotResolvedPrimitiveType<" + kind + ">";
195 }
196
197 @Override
198 public AssumptionResult<ResolvedJavaType> findLeafConcreteSubtype() {
199 return new AssumptionResult<>(this);
200 }
201
202 @Override
203 public AssumptionResult<ResolvedJavaMethod> findUniqueConcreteMethod(ResolvedJavaMethod method) {
204 return null;
205 }
206
207 @Override
208 public ResolvedJavaField[] getInstanceFields(boolean includeSuperclasses) {
209 return new ResolvedJavaField[0];
210 }
211
212 @Override
213 public ResolvedJavaField[] getStaticFields() {
214 return new ResolvedJavaField[0];
215 }
216
217 @Override
218 public Annotation[] getAnnotations() {
219 return new Annotation[0];
220 }
221
222 @Override
223 public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
224 return null;
225 }
226
227 @Override
228 public ResolvedJavaType resolve(ResolvedJavaType accessingClass) {
229 requireNonNull(accessingClass);
230 return this;
231 }
232
233 @Override
234 public void initialize() {
235 }
236
237 @Override
238 public ResolvedJavaField findInstanceFieldWithOffset(long offset, JavaKind expectedType) {
239 return null;
240 }
241
242 @Override
243 public String getSourceFileName() {
244 throw JVMCIError.unimplemented();
245 }
246
247 @Override
248 public Class<?> mirror() {
249 return kind.toJavaClass();
250 }
251
252 @Override
253 public URL getClassFilePath() {
254 return null;
255 }
256
257 @Override
258 public boolean isLocal() {
259 return false;
260 }
261
262 @Override
263 public boolean isMember() {
264 return false;
265 }
266
267 @Override
268 public ResolvedJavaType getEnclosingType() {
269 return null;
270 }
271
272 @Override
273 public ResolvedJavaMethod[] getDeclaredConstructors() {
274 return new ResolvedJavaMethod[0];
275 }
276
277 @Override
278 public ResolvedJavaMethod[] getDeclaredMethods() {
279 return new ResolvedJavaMethod[0];
280 }
281
282 @Override
283 public ResolvedJavaMethod getClassInitializer() {
284 return null;
285 }
286
287 @Override
288 public boolean isTrustedInterfaceType() {
289 return false;
290 }
291 }