author | erikj |
Tue, 12 Sep 2017 19:03:39 +0200 | |
changeset 47216 | 71c04702a3d5 |
parent 45714 | jdk/src/jdk.jdi/share/classes/com/sun/tools/jdi/MethodImpl.java@1820d351198d |
permissions | -rw-r--r-- |
2 | 1 |
/* |
45714 | 2 |
* Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved. |
2 | 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 |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 10 |
* |
11 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
15 |
* accompanied this code). |
|
16 |
* |
|
17 |
* You should have received a copy of the GNU General Public License version |
|
18 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
19 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 |
* |
|
5506 | 21 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
22 |
* or visit www.oracle.com if you need additional information or have any |
|
23 |
* questions. |
|
2 | 24 |
*/ |
25 |
||
26 |
package com.sun.tools.jdi; |
|
27 |
||
45714 | 28 |
import java.util.ArrayList; |
2 | 29 |
import java.util.List; |
45714 | 30 |
|
31 |
import com.sun.jdi.AbsentInformationException; |
|
32 |
import com.sun.jdi.ArrayReference; |
|
33 |
import com.sun.jdi.ArrayType; |
|
34 |
import com.sun.jdi.ClassNotLoadedException; |
|
35 |
import com.sun.jdi.InterfaceType; |
|
36 |
import com.sun.jdi.InvalidTypeException; |
|
37 |
import com.sun.jdi.Location; |
|
38 |
import com.sun.jdi.Method; |
|
39 |
import com.sun.jdi.Type; |
|
40 |
import com.sun.jdi.Value; |
|
41 |
import com.sun.jdi.VirtualMachine; |
|
2 | 42 |
|
43 |
public abstract class MethodImpl extends TypeComponentImpl |
|
45714 | 44 |
implements Method |
45 |
{ |
|
2 | 46 |
private JNITypeParser signatureParser; |
45714 | 47 |
|
2 | 48 |
abstract int argSlotCount() throws AbsentInformationException; |
49 |
||
50 |
abstract List<Location> allLineLocations(SDE.Stratum stratum, |
|
45714 | 51 |
String sourceName) |
52 |
throws AbsentInformationException; |
|
2 | 53 |
|
54 |
abstract List<Location> locationsOfLine(SDE.Stratum stratum, |
|
45714 | 55 |
String sourceName, |
56 |
int lineNumber) |
|
57 |
throws AbsentInformationException; |
|
2 | 58 |
|
59 |
MethodImpl(VirtualMachine vm, ReferenceTypeImpl declaringType, |
|
45714 | 60 |
long ref, String name, String signature, |
2 | 61 |
String genericSignature, int modifiers) { |
62 |
super(vm, declaringType, ref, name, signature, |
|
63 |
genericSignature, modifiers); |
|
64 |
signatureParser = new JNITypeParser(signature); |
|
65 |
} |
|
66 |
||
67 |
static MethodImpl createMethodImpl(VirtualMachine vm, |
|
68 |
ReferenceTypeImpl declaringType, |
|
69 |
long ref, |
|
70 |
String name, |
|
71 |
String signature, |
|
72 |
String genericSignature, |
|
73 |
int modifiers) { |
|
45714 | 74 |
if ((modifiers & (VMModifiers.NATIVE | VMModifiers.ABSTRACT)) != 0) { |
2 | 75 |
return new NonConcreteMethodImpl(vm, declaringType, ref, |
76 |
name, signature, |
|
77 |
genericSignature, |
|
78 |
modifiers); |
|
79 |
} else { |
|
80 |
return new ConcreteMethodImpl(vm, declaringType, ref, |
|
81 |
name, signature, |
|
82 |
genericSignature, |
|
83 |
modifiers); |
|
84 |
} |
|
85 |
} |
|
86 |
||
87 |
public boolean equals(Object obj) { |
|
88 |
if ((obj != null) && (obj instanceof MethodImpl)) { |
|
89 |
MethodImpl other = (MethodImpl)obj; |
|
90 |
return (declaringType().equals(other.declaringType())) && |
|
91 |
(ref() == other.ref()) && |
|
92 |
super.equals(obj); |
|
93 |
} else { |
|
94 |
return false; |
|
95 |
} |
|
96 |
} |
|
97 |
||
98 |
public int hashCode() { |
|
99 |
return (int)ref(); |
|
100 |
} |
|
101 |
||
102 |
public final List<Location> allLineLocations() |
|
45714 | 103 |
throws AbsentInformationException { |
2 | 104 |
return allLineLocations(vm.getDefaultStratum(), null); |
105 |
} |
|
106 |
||
107 |
public List<Location> allLineLocations(String stratumID, |
|
45714 | 108 |
String sourceName) |
109 |
throws AbsentInformationException { |
|
110 |
return allLineLocations(declaringType.stratum(stratumID), sourceName); |
|
2 | 111 |
} |
112 |
||
113 |
public final List<Location> locationsOfLine(int lineNumber) |
|
45714 | 114 |
throws AbsentInformationException { |
2 | 115 |
return locationsOfLine(vm.getDefaultStratum(), |
116 |
null, lineNumber); |
|
117 |
} |
|
118 |
||
119 |
public List<Location> locationsOfLine(String stratumID, |
|
45714 | 120 |
String sourceName, |
121 |
int lineNumber) |
|
122 |
throws AbsentInformationException { |
|
2 | 123 |
return locationsOfLine(declaringType.stratum(stratumID), |
124 |
sourceName, lineNumber); |
|
125 |
} |
|
126 |
||
127 |
LineInfo codeIndexToLineInfo(SDE.Stratum stratum, |
|
128 |
long codeIndex) { |
|
129 |
if (stratum.isJava()) { |
|
130 |
return new BaseLineInfo(-1, declaringType); |
|
131 |
} else { |
|
45714 | 132 |
return new StratumLineInfo(stratum.id(), -1, null, null); |
2 | 133 |
} |
134 |
} |
|
135 |
||
136 |
/** |
|
137 |
* @return a text representation of the declared return type |
|
138 |
* of this method. |
|
139 |
*/ |
|
140 |
public String returnTypeName() { |
|
141 |
return signatureParser.typeName(); |
|
142 |
} |
|
143 |
||
144 |
private String returnSignature() { |
|
145 |
return signatureParser.signature(); |
|
146 |
} |
|
147 |
||
148 |
public Type returnType() throws ClassNotLoadedException { |
|
149 |
return findType(returnSignature()); |
|
150 |
} |
|
151 |
||
152 |
public Type findType(String signature) throws ClassNotLoadedException { |
|
153 |
ReferenceTypeImpl enclosing = (ReferenceTypeImpl)declaringType(); |
|
154 |
return enclosing.findType(signature); |
|
155 |
} |
|
156 |
||
157 |
public List<String> argumentTypeNames() { |
|
158 |
return signatureParser.argumentTypeNames(); |
|
159 |
} |
|
160 |
||
161 |
public List<String> argumentSignatures() { |
|
162 |
return signatureParser.argumentSignatures(); |
|
163 |
} |
|
164 |
||
165 |
Type argumentType(int index) throws ClassNotLoadedException { |
|
166 |
ReferenceTypeImpl enclosing = (ReferenceTypeImpl)declaringType(); |
|
51 | 167 |
String signature = argumentSignatures().get(index); |
2 | 168 |
return enclosing.findType(signature); |
169 |
} |
|
170 |
||
171 |
public List<Type> argumentTypes() throws ClassNotLoadedException { |
|
172 |
int size = argumentSignatures().size(); |
|
45714 | 173 |
List<Type> types = new ArrayList<>(size); |
2 | 174 |
for (int i = 0; i < size; i++) { |
175 |
Type type = argumentType(i); |
|
176 |
types.add(type); |
|
177 |
} |
|
178 |
||
179 |
return types; |
|
180 |
} |
|
181 |
||
182 |
public int compareTo(Method method) { |
|
183 |
ReferenceTypeImpl declaringType = (ReferenceTypeImpl)declaringType(); |
|
184 |
int rc = declaringType.compareTo(method.declaringType()); |
|
185 |
if (rc == 0) { |
|
45714 | 186 |
rc = declaringType.indexOf(this) - declaringType.indexOf(method); |
2 | 187 |
} |
188 |
return rc; |
|
189 |
} |
|
190 |
||
191 |
public boolean isAbstract() { |
|
192 |
return isModifierSet(VMModifiers.ABSTRACT); |
|
193 |
} |
|
194 |
||
24195
705325a63a58
8042123: Support default and static interface methods in JDI, JDWP and JDB
jbachorik
parents:
24127
diff
changeset
|
195 |
public boolean isDefault() { |
705325a63a58
8042123: Support default and static interface methods in JDI, JDWP and JDB
jbachorik
parents:
24127
diff
changeset
|
196 |
return !isModifierSet(VMModifiers.ABSTRACT) && |
705325a63a58
8042123: Support default and static interface methods in JDI, JDWP and JDB
jbachorik
parents:
24127
diff
changeset
|
197 |
!isModifierSet(VMModifiers.STATIC) && |
705325a63a58
8042123: Support default and static interface methods in JDI, JDWP and JDB
jbachorik
parents:
24127
diff
changeset
|
198 |
!isModifierSet(VMModifiers.PRIVATE) && |
705325a63a58
8042123: Support default and static interface methods in JDI, JDWP and JDB
jbachorik
parents:
24127
diff
changeset
|
199 |
declaringType() instanceof InterfaceType; |
705325a63a58
8042123: Support default and static interface methods in JDI, JDWP and JDB
jbachorik
parents:
24127
diff
changeset
|
200 |
} |
705325a63a58
8042123: Support default and static interface methods in JDI, JDWP and JDB
jbachorik
parents:
24127
diff
changeset
|
201 |
|
2 | 202 |
public boolean isSynchronized() { |
203 |
return isModifierSet(VMModifiers.SYNCHRONIZED); |
|
204 |
} |
|
205 |
||
206 |
public boolean isNative() { |
|
207 |
return isModifierSet(VMModifiers.NATIVE); |
|
208 |
} |
|
209 |
||
210 |
public boolean isVarArgs() { |
|
211 |
return isModifierSet(VMModifiers.VARARGS); |
|
212 |
} |
|
213 |
||
214 |
public boolean isBridge() { |
|
215 |
return isModifierSet(VMModifiers.BRIDGE); |
|
216 |
} |
|
217 |
||
218 |
public boolean isConstructor() { |
|
219 |
return name().equals("<init>"); |
|
220 |
} |
|
221 |
||
222 |
public boolean isStaticInitializer() { |
|
223 |
return name().equals("<clinit>"); |
|
224 |
} |
|
225 |
||
226 |
public boolean isObsolete() { |
|
227 |
try { |
|
228 |
return JDWP.Method.IsObsolete.process(vm, |
|
229 |
declaringType, ref).isObsolete; |
|
230 |
} catch (JDWPException exc) { |
|
231 |
throw exc.toJDIException(); |
|
232 |
} |
|
233 |
} |
|
234 |
||
235 |
/* |
|
236 |
* A container class for the return value to allow |
|
237 |
* proper type-checking. |
|
238 |
*/ |
|
239 |
class ReturnContainer implements ValueContainer { |
|
240 |
ReturnContainer() { |
|
241 |
} |
|
242 |
public Type type() throws ClassNotLoadedException { |
|
243 |
return returnType(); |
|
244 |
} |
|
245 |
public String typeName(){ |
|
246 |
return returnTypeName(); |
|
247 |
} |
|
248 |
public String signature() { |
|
249 |
return returnSignature(); //type().signature(); |
|
250 |
} |
|
251 |
public Type findType(String signature) throws ClassNotLoadedException { |
|
252 |
return MethodImpl.this.findType(signature); |
|
253 |
} |
|
254 |
} |
|
255 |
ReturnContainer retValContainer = null; |
|
256 |
ReturnContainer getReturnValueContainer() { |
|
257 |
if (retValContainer == null) { |
|
258 |
retValContainer = new ReturnContainer(); |
|
259 |
} |
|
260 |
return retValContainer; |
|
261 |
} |
|
262 |
||
263 |
/* |
|
264 |
* A container class for the argument to allow |
|
265 |
* proper type-checking. |
|
266 |
*/ |
|
267 |
class ArgumentContainer implements ValueContainer { |
|
268 |
int index; |
|
269 |
||
270 |
ArgumentContainer(int index) { |
|
271 |
this.index = index; |
|
272 |
} |
|
273 |
public Type type() throws ClassNotLoadedException { |
|
274 |
return argumentType(index); |
|
275 |
} |
|
276 |
public String typeName(){ |
|
51 | 277 |
return argumentTypeNames().get(index); |
2 | 278 |
} |
279 |
public String signature() { |
|
51 | 280 |
return argumentSignatures().get(index); |
2 | 281 |
} |
282 |
public Type findType(String signature) throws ClassNotLoadedException { |
|
283 |
return MethodImpl.this.findType(signature); |
|
284 |
} |
|
285 |
} |
|
286 |
||
287 |
/* |
|
288 |
* This is a var args method. Thus, its last param is an |
|
289 |
* array. If the method has n params, then: |
|
290 |
* 1. If there are n args and the last is the same type as the type of |
|
291 |
* the last param, do nothing. IE, a String[] |
|
292 |
* can be passed to a String... |
|
293 |
* 2. If there are >= n arguments and for each arg whose number is >= n, |
|
294 |
* the arg type is 'compatible' with the component type of |
|
295 |
* the last param, then do |
|
296 |
* - create an array of the type of the last param |
|
297 |
* - put the n, ... args into this array. |
|
298 |
* We might have to do conversions here. |
|
299 |
* - put this array into arguments(n) |
|
300 |
* - delete arguments(n+1), ... |
|
301 |
* NOTE that this might modify the input list. |
|
302 |
*/ |
|
303 |
void handleVarArgs(List<Value> arguments) |
|
304 |
throws ClassNotLoadedException, InvalidTypeException { |
|
305 |
List<Type> paramTypes = this.argumentTypes(); |
|
306 |
ArrayType lastParamType = (ArrayType)paramTypes.get(paramTypes.size() - 1); |
|
307 |
int argCount = arguments.size(); |
|
308 |
int paramCount = paramTypes.size(); |
|
309 |
if (argCount < paramCount - 1) { |
|
310 |
// Error; will be caught later. |
|
311 |
return; |
|
312 |
} |
|
313 |
if (argCount == paramCount - 1) { |
|
314 |
// It is ok to pass 0 args to the var arg. |
|
315 |
// We have to gen a 0 length array. |
|
316 |
ArrayReference argArray = lastParamType.newInstance(0); |
|
317 |
arguments.add(argArray); |
|
318 |
return; |
|
319 |
} |
|
51 | 320 |
Value nthArgValue = arguments.get(paramCount - 1); |
42676
36fa143f8de8
8160024: jdb returns invalid argument count if first parameter to Arrays.asList is null
sspitsyn
parents:
25859
diff
changeset
|
321 |
if (nthArgValue == null && argCount == paramCount) { |
36fa143f8de8
8160024: jdb returns invalid argument count if first parameter to Arrays.asList is null
sspitsyn
parents:
25859
diff
changeset
|
322 |
// We have one varargs parameter and it is null |
36fa143f8de8
8160024: jdb returns invalid argument count if first parameter to Arrays.asList is null
sspitsyn
parents:
25859
diff
changeset
|
323 |
// so we don't have to do anything. |
2 | 324 |
return; |
325 |
} |
|
42676
36fa143f8de8
8160024: jdb returns invalid argument count if first parameter to Arrays.asList is null
sspitsyn
parents:
25859
diff
changeset
|
326 |
// If the first varargs parameter is null, then don't |
36fa143f8de8
8160024: jdb returns invalid argument count if first parameter to Arrays.asList is null
sspitsyn
parents:
25859
diff
changeset
|
327 |
// access its type since it can't be an array. |
36fa143f8de8
8160024: jdb returns invalid argument count if first parameter to Arrays.asList is null
sspitsyn
parents:
25859
diff
changeset
|
328 |
Type nthArgType = (nthArgValue == null) ? null : nthArgValue.type(); |
2 | 329 |
if (nthArgType instanceof ArrayTypeImpl) { |
330 |
if (argCount == paramCount && |
|
331 |
((ArrayTypeImpl)nthArgType).isAssignableTo(lastParamType)) { |
|
332 |
/* |
|
333 |
* This is case 1. A compatible array is being passed to the |
|
334 |
* var args array param. We don't have to do anything. |
|
335 |
*/ |
|
336 |
return; |
|
337 |
} |
|
338 |
} |
|
339 |
||
340 |
/* |
|
341 |
* Case 2. We have to verify that the n, n+1, ... args are compatible |
|
342 |
* with componentType, and do conversions if necessary and create |
|
343 |
* an array of componentType to hold these possibly converted values. |
|
344 |
*/ |
|
345 |
int count = argCount - paramCount + 1; |
|
346 |
ArrayReference argArray = lastParamType.newInstance(count); |
|
347 |
||
348 |
/* |
|
349 |
* This will copy arguments(paramCount - 1) ... to argArray(0) ... |
|
350 |
* doing whatever conversions are needed! It will throw an |
|
351 |
* exception if an incompatible arg is encountered |
|
352 |
*/ |
|
353 |
argArray.setValues(0, arguments, paramCount - 1, count); |
|
354 |
arguments.set(paramCount - 1, argArray); |
|
355 |
||
356 |
/* |
|
357 |
* Remove the excess args |
|
358 |
*/ |
|
359 |
for (int ii = paramCount; ii < argCount; ii++) { |
|
360 |
arguments.remove(paramCount); |
|
361 |
} |
|
362 |
return; |
|
363 |
} |
|
364 |
||
365 |
/* |
|
366 |
* The output list will be different than the input list. |
|
367 |
*/ |
|
368 |
List<Value> validateAndPrepareArgumentsForInvoke(List<? extends Value> origArguments) |
|
369 |
throws ClassNotLoadedException, InvalidTypeException { |
|
370 |
||
45714 | 371 |
List<Value> arguments = new ArrayList<>(origArguments); |
2 | 372 |
if (isVarArgs()) { |
373 |
handleVarArgs(arguments); |
|
374 |
} |
|
375 |
||
376 |
int argSize = arguments.size(); |
|
377 |
||
378 |
JNITypeParser parser = new JNITypeParser(signature()); |
|
11277 | 379 |
List<String> signatures = parser.argumentSignatures(); |
2 | 380 |
|
381 |
if (signatures.size() != argSize) { |
|
382 |
throw new IllegalArgumentException("Invalid argument count: expected " + |
|
383 |
signatures.size() + ", received " + |
|
384 |
arguments.size()); |
|
385 |
} |
|
386 |
||
387 |
for (int i = 0; i < argSize; i++) { |
|
51 | 388 |
Value value = arguments.get(i); |
2 | 389 |
value = ValueImpl.prepareForAssignment(value, |
390 |
new ArgumentContainer(i)); |
|
391 |
arguments.set(i, value); |
|
392 |
} |
|
393 |
return arguments; |
|
394 |
} |
|
395 |
||
396 |
public String toString() { |
|
24969
afa6934dd8e8
8041679: Replace uses of StringBuffer with StringBuilder within core library classes
psandoz
parents:
24195
diff
changeset
|
397 |
StringBuilder sb = new StringBuilder(); |
2 | 398 |
sb.append(declaringType().name()); |
399 |
sb.append("."); |
|
400 |
sb.append(name()); |
|
401 |
sb.append("("); |
|
402 |
boolean first = true; |
|
51 | 403 |
for (String name : argumentTypeNames()) { |
2 | 404 |
if (!first) { |
405 |
sb.append(", "); |
|
406 |
} |
|
51 | 407 |
sb.append(name); |
2 | 408 |
first = false; |
409 |
} |
|
410 |
sb.append(")"); |
|
411 |
return sb.toString(); |
|
412 |
} |
|
413 |
} |