Compiler generation of instruction sequences for unresolved storage references

A computer program product comprising a computer usable medium tangibly embodying computer readable program code means for defining a Java runtime environment, said computer readable program code means comprising a Java just in time compiler and an associated runtime helper, the runtime helper being defined for resolving references at runtime, the compiler comprising means to emit compiled code including a set of target instructions, each target instruction having an associated target location in the emitted compiled code, each target instruction including one or more unresolved references at compile time, the means to emit the compiled code comprising:

• code means for directing the computer to first emit, for each one of the set of target instructions, an associated unresolved target instruction at the corresponding target location;
• code means for directing the computer to create and maintain a snippet list comprising entries, each entry in the snippet list corresponding to one of the set of target instructions;
• code means for directing the computer to subsequently traverse the snippet list to emit compiled code, for each target instruction, comprising:
• a snippet comprising instructions and data for calling the runtime helper to resolve the unresolved references in the target instruction at runtime, and comprising a copy of the target instruction including the unresolved references, and
• a call instruction to the snippet, the call instruction being written to the target location in the emitted compiled code,
• the runtime helper comprising instructions for a specified target instruction to resolve the unresolved references of the specified target instruction at runtime and for the specified target instruction, to replace the associated trigger instruction at a specified target location with the copy of the specified target instruction having the unresolved reference resolved.

A method of generating compiled code for an instruction having an unresolved compile-time reference, comprising the acts of:

• specifying a runtime helper routine for resolving unresolved references at runtime;
• emitting unresolved code in the generated compiled code comprising a default reference value being a placeholder for an unresolved reference;
• emitting a snippet comprising instructions and data to identify the unresolved emitted code in the compiled code and to call and provide data to the runtime helper routine to permit the unresolved reference to be resolved;
• storing a copy of the emitted unresolved code in the snippet;
• and
• replacing the unresolved emitted code in the compiled code with a call instruction for calling the snippet, the runtime helper routine being defined to resolve references at runtime with respect to the copy of the emitted unresolved code in the snippet to define a resolved instruction and to replace the call instruction for calling the snippet with the resolved instruction.

A method for emitting compiled computer code to resolve references in a set of target instructions, each target instruction to be executed at a target location in the compiled code, each target instruction including an unresolved reference at compile time, the method comprising:

• emitting a trigger instruction for each target instruction, the trigger instruction being located at the target location in the compiled code;
• and
• emitting a snippet for each target instruction comprising a copy of the target instruction including the unresolved reference and resolution data useable by a runtime helper,
• each trigger instruction being defined to trigger the execution of defined instructions to pass a specified set of resolution data to the runtime helper for resolution of the unresolved reference in a specified copy of a target instruction and to replace the trigger instruction at the target location with the specified copy of the target instruction having the unresolved reference resolved.