-
Notifications
You must be signed in to change notification settings - Fork 6.2k
8357660: [JVMCI] Add support for retrieving all BootstrapMethodInvocations directly from ConstantPool #25420
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Conversation
|
Hi @teshull, welcome to this OpenJDK project and thanks for contributing! We do not recognize you as Contributor and need to ensure you have signed the Oracle Contributor Agreement (OCA). If you have not signed the OCA, please follow the instructions. Please fill in your GitHub username in the "Username" field of the application. Once you have signed the OCA, please let us know by writing If you already are an OpenJDK Author, Committer or Reviewer, please click here to open a new issue so that we can record that fact. Please use "Add GitHub user teshull" as summary for the issue. If you are contributing this work on behalf of your employer and your employer has signed the OCA, please let us know by writing |
|
@teshull This change now passes all automated pre-integration checks. ℹ️ This project also has non-automated pre-integration requirements. Please see the file CONTRIBUTING.md for details. After integration, the commit message for the final commit will be: You can use pull request commands such as /summary, /contributor and /issue to adjust it as needed. At the time when this comment was updated there had been 12 new commits pushed to the
As there are no conflicts, your changes will automatically be rebased on top of these commits when integrating. If you prefer to avoid this automatic rebasing, please check the documentation for the /integrate command for further details. As you do not have Committer status in this project an existing Committer must agree to sponsor your change. Possible candidates are the reviewers of this PR (@dougxc, @mur47x111) but any other Committer may sponsor as well. ➡️ To flag this PR as ready for integration with the above commit message, type |
|
/covered |
|
Thank you! Please allow for a few business days to verify that your employer has signed the OCA. Also, please note that pull requests that are pending an OCA check will not usually be evaluated, so your patience is appreciated! |
|
Please add some tests for the new methods to |
|
@dougxc I integrated testing for the new methods into |
src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/CompilerToVM.java
Outdated
Show resolved
Hide resolved
src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ConstantPool.java
Outdated
Show resolved
Hide resolved
| * constant pool contains no invokedynamic BootstrapMethodInvocations, then null | ||
| * is returned. | ||
| */ | ||
| BootstrapMethodInvocation[] lookupAllIndyBootstrapMethodInvocations(); |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Why not make this return all BootstrapMethodInvocations? The caller can then filter out the indy ones with isInvokeDynamic. Also, please return a List<BootstrapMethodInvocation> instead of an array - we should never return arrays from JVMCI (see #23159 as an example of addressing existing API). Lastly, return List.of() instead of null.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Changed to return a list.
Why not make this return all BootstrapMethodInvocations
- Within HotSpot it is very easy to pick off all indy BootstrapMethodInvocations via the ConstantPoolCache
- Each invokedynamic bytecode location has a unique BootstrapMethodInvocation instance, but they may share the same constant pool entry, so it's not trivial to find all BootstrapMethodInvocations. One would have to iterate both all method bytecodes and constant pool slots, and do some additional filtering.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
How about List<BootstrapMethodInvocation> lookupBootstrapMethodInvocations(boolean indy)? That is, it either gets the indy or the condy BSM invocations. I can imagine SVM wanting the latter at some point right?
BTW, I noticed that the javadoc for ConstantPool.lookupBootstrapMethodInvocation is somewhat incorrect. Please check and apply these corrections in this PR:
diff --git a/src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ConstantPool.java b/src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ConstantPool.java
index 2273b256f03..3519af4bcbb 100644
--- a/src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ConstantPool.java
+++ b/src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/meta/ConstantPool.java
@@ -199,12 +199,12 @@ interface BootstrapMethodInvocation {
* in the constant pool.
*
* @param index if {@code opcode} is -1, {@code index} is a constant pool index. Otherwise {@code opcode}
- * must be {@code Bytecodes.INVOKEDYNAMIC}, and {@code index} must be the operand of that
- * opcode in the bytecode stream (i.e., a {@code rawIndex}).
- * @param opcode must be {@code Bytecodes.INVOKEDYNAMIC}, or -1 if
+ * must be {@code Bytecodes.INVOKEDYNAMIC} or {@code CONSTANT_Dynamic_info}, and {@code index}
+ * must be the operand of that opcode in the bytecode stream (i.e., a {@code rawIndex}).
+ * @param opcode must be {@code Bytecodes.INVOKEDYNAMIC}, {@code CONSTANT_Dynamic_info}, or -1 if
* {@code index} was not decoded from a bytecode stream
* @return the bootstrap method invocation details or {@code null} if the entry specified by {@code index}
- * is not a {@code CONSTANT_Dynamic_info} or @{code CONSTANT_InvokeDynamic_info}
+ * is not a {@code CONSTANT_Dynamic_info} or {@code CONSTANT_InvokeDynamic_info}
* @jvms 4.7.23 The {@code BootstrapMethods} Attribute
*/
default BootstrapMethodInvocation lookupBootstrapMethodInvocation(int index, int opcode) {
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I prototyped the option List<BootstrapMethodInvocation> lookupBootstrapMethodInvocations(boolean indy) here: master...teshull:jdk:jvmci_bootstrap_alternative
As part of this I also prototyped generic BSM resolution / lookup logic
From the SVM perspective, retrieving condys via this new support isn't a big win. It's easy enough already to walk the ConstantPool. However, for symmetry purposes, it is reasonable to have this method (along with the resolve / lookup). What's your preference: this new version or the original?
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I like the symmetry of the new version. Also, I think you can simplify things by replacing use of flatMap here with filter.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I updated the javadoc misplaced @ in {@code}. However, the opcode doc changes look wrong to me; the opcode must be -1 or INVOKEDYNAMIC (
jdk/src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotConstantPool.java
Line 592 in 04e0fe0
| int cpi = opcode == -1 ? index : indyIndexConstantPoolIndex(index, opcode); |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
yeah, looks like you're right. I was basing my assumption on case "Dynamic" in:
@Override
public BootstrapMethodInvocation lookupBootstrapMethodInvocation(int index, int opcode) {
int cpi = opcode == -1 ? index : indyIndexConstantPoolIndex(index, opcode);
final JvmConstant tag = getTagAt(cpi);
switch (tag.name) {
case "InvokeDynamic":
case "Dynamic":
I guess it's possible for an INVOKEDYNAMIC to resolve it's cpi to a CONSTANT_Dynamic entry.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I think INVOKEDYNAMIC should always point to a CONSTANT_InvokeDynamic entry
| } | ||
|
|
||
| /** | ||
| * Returns the BootstrapMethodInvocation instances for all invokedynamic |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Point out that the returned list is unmodifiable (like the API for Stream.toList() does).
|
@dougxc I cleaned up the PR to now have the symmetric lookup option and updated the tests |
src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotConstantPool.java
Outdated
Show resolved
Hide resolved
src/jdk.internal.vm.ci/share/classes/jdk/vm/ci/hotspot/HotSpotConstantPool.java
Outdated
Show resolved
Hide resolved
Co-authored-by: Douglas Simon <[email protected]>
Co-authored-by: Douglas Simon <[email protected]>
| } else { | ||
| return IntStream.range(1, length()).filter(cpi -> { | ||
| return IntStream.range(1, length()) | ||
| .filter(this::isDynamicEntry) |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Looks like you forgot to add the definition of isDynamicEntry that I suggested:
private boolean isDynamicEntry(int cpi) {
JvmConstant tagAt = getTagAt(cpi);
return tagAt != null && tagAt.name.equals("Dynamic");
}
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Yes, I applied the suggested change via github, and am just validating it works now (which of course it doesn't). I'll fix it
|
I also updated the title of https://bugs.openjdk.org/browse/JDK-8357660 to Not Be All Capitalized so you'll need to fix the title of this PR. |
| private final String name; | ||
| private final JavaConstant type; | ||
| private final List<JavaConstant> staticArguments; | ||
| private final int index; |
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
index -> cpiOrIndyIndex
Webrevs
|
dougxc
left a comment
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Looks good to me.
Please enable GitHub Actions on your JDK fork.
mur47x111
left a comment
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
LGTM
|
/integrate |
|
/sponsor |
|
Going to push as commit 0352477.
Your commit was automatically rebased without conflicts. |
This PR adds support for directly retrieving both all invokedynamic and all condy BootstrapMethodInvocations from a ConstantPool via the new method
List<BootstrapMethodInvocation> lookupBootstrapMethodInvocations(boolean invokeDynamic).In addition, two methods are added to the BootstrapMethodInvocations:
void resolve()JavaConstant lookup()The combination of these two features allows one to directly interact with all BSM information of a given ConstantPool without having to iterate through all of the Classfile's methods to find all invokedynamic bytecodes and/or iterate through all Constant Pool entries.
Progress
Issue
Reviewers
Reviewing
Using
gitCheckout this PR locally:
$ git fetch https://git.openjdk.org/jdk.git pull/25420/head:pull/25420$ git checkout pull/25420Update a local copy of the PR:
$ git checkout pull/25420$ git pull https://git.openjdk.org/jdk.git pull/25420/headUsing Skara CLI tools
Checkout this PR locally:
$ git pr checkout 25420View PR using the GUI difftool:
$ git pr show -t 25420Using diff file
Download this PR as a diff file:
https://git.openjdk.org/jdk/pull/25420.diff
Using Webrev
Link to Webrev Comment