IJ41694: INCORRECT JIT OPTIMIZATION OF JAVA CODE

APAR status

• Closed as program error.

Error description

• Error Message: The problem can result in a wide variety of
  symptoms including but not limited to unexpected exceptions,
  incorrect behavior and incorrect calculations.
  .
  Stack Trace: If the problem presents as a JIT compile time
  crash, the stack trace would look like this:
     TR::VPConstraint::intersect
     OMR::ValuePropagation::addGlobalConstraint
     OMR::ValuePropagation::getConstraint
     canFoldNonOverriddenGuard
     constrainIfcmpeqne
  For other types of symptoms the stack trace will depend on the
  Java code being executed.
  .
  The problem can cause the Java JIT compiler to make incorrect
  assumptions about the class of an object that is being used in
  an operation or cause it to assume incorrectly that a reference
  must be null or that it must be non-null.  This can result in
  incorrect optimizations being performed by the JIT compiler -
  for example, it might remove checks of whether a
  NullPointerException or ClassCastException should be thrown, it
  might change the code to cause such exceptions to be thrown
  always, it might assume that the implementation of a method
  defined by a particular class will be invoked based on an
  incorrect assumption about the class of an object, and so on.
  Those incorrect optimizations might result in unexpected
  exceptions or errors being thrown, result in expected exceptions
  or errors not being detected, or result in other incorrect
  behavior. The issue can occur starting with Java 8.0.5.36 on all
  platforms and JVM configurations as long as the JIT is enabled
  

Local fix

• The problem can be avoided by specifying the java command line
  option -Xjit:disableGlobalVP.  Specifying that option will
  likely have a noticeable impact on performance of a Java
  program.
  

Problem summary

• The problem is triggered when the Java JIT compiler generates
  inline code for a reference to a method along with code that
  determines, while the code is running, whether to run the
  inlined version of the method or to perform an actual method
  invocation.  Subsequent optimizations might result in two or
  more copies of the code that makes that run-time determination.
  In analyzing whether one of those copies of the code will always
  select the inlined version of the method, the JIT compiler
  might
  not take into account the presence of the other copies of that
  code and make incorrect assumptions about values that reach the
  point of the call.
  

Problem conclusion

• The problem was resolved by changing the Java JIT compiler to
  analyze whether the block of code that makes the run-time
  determination will always select the inlined version of the
  method only if there is no other copy of that block of code.
  .
  This APAR will be fixed in the following Releases:
  .
  IBM SDK, Java Technology Edition
     8    SR7 FP16  (8.0.7.16)
  .
  Contact your IBM Product's Service Team for these Service
  Refreshes and Fix Packs.
  For those running stand-alone, information about the available
  maintenance can be found at:
             https://www.ibm.com/support/pages/java-sdk
  

Temporary fix

Comments

APAR Information

• APAR is sysrouted FROM one or more of the following:

• APAR is sysrouted TO one or more of the following:

Fix information

• Fixed component name

  JIT

• Fixed component ID

  620700124

Applicable component levels