Mercurial > jdk8-mips64-public > nashorn / changeset

     1.1 --- a/.hgtags	Mon Oct 27 14:36:13 2014 -0700
     1.2 +++ b/.hgtags	Thu Nov 06 09:50:15 2014 -0800
     1.3 @@ -328,6 +328,8 @@
     1.4  3505d266634ded89bf9617ff6b385ab8a52f78cf jdk8u31-b03
     1.5  96acff2ad9e19aa80c4f7ed60d87a422bca1ea91 jdk8u31-b04
     1.6  5fc3f210872d365c57ed4e8dba3926d9ed5c7e45 jdk8u31-b05
     1.7 +99a3333f7f8489bb3c80f0c0643ae19e549a0941 jdk8u31-b06
     1.8 +5ed4fa732b26b6d8e37dfc5bbd00047c5352719b jdk8u31-b07
     1.9  f2925491b61b22ac42f8c30ee9c6723ffa401a4c jdk8u40-b00
    1.10  62468d841b842769d875bd97d10370585c296eb7 jdk8u40-b01
    1.11  b476c69c820ac1e05071f4de5abab8e2dff80e87 jdk8u40-b02
    1.12 @@ -340,4 +342,6 @@
    1.13  6a8ecdeae4a9a438eed637b5a5d0d18fddb9f711 jdk8u40-b09
    1.14  076b1f38a5ccd4692a6f93939a7fc03bc1a1bbb4 jdk8u40-b10
    1.15  57c7b273277e00f7a98fafb18ff07aa3245808f0 jdk8u40-b11
    1.16 +375a3a3256d041fe7334638a95e69b4c11d6104b jdk8u40-b12
    1.17 +d60fbb5343c186abbf92b0259e67efb3b71377b4 jdk8u40-b13
    1.18  05a3614ed5276e5db2a73cce918be04b1a2922fb jdk8u45-b00

     2.1 --- a/bin/runopt.sh	Mon Oct 27 14:36:13 2014 -0700
     2.2 +++ b/bin/runopt.sh	Thu Nov 06 09:50:15 2014 -0800
     2.3 @@ -28,14 +28,35 @@
     2.4  # known flags for performance for the current configration
     2.5  ###########################################################################################
     2.6  
     2.7 +# Flags to enable assertions, we need the system assertions too, since
     2.8 +# this script runs Nashorn in the BCP to override any nashorn.jar that might
     2.9 +# reside in your $JAVA_HOME/jre/lib/ext/nashorn.jar
    2.10 +#
    2.11 +ENABLE_ASSERTIONS_FLAGS="-ea -esa"
    2.12 +
    2.13  # Flags to instrument lambdaform computation, caching, interpretation and compilation
    2.14  # Default compile threshold for lambdaforms is 30
    2.15 -#FLAGS="-Djava.lang.invoke.MethodHandle.COMPILE_THRESHOLD=3 -Djava.lang.invoke.MethodHandle.DUMP_CLASS_FILES=true -Djava.lang.invoke.MethodHandle.TRACE_METHOD_LINKAGE=true -Djava.lang.invoke.MethodHandle.TRACE_INTERPRETER=true"
    2.16 -
    2.17 +#
    2.18 +#LAMBDAFORM_FLAGS="\
    2.19 +#    -Djava.lang.invoke.MethodHandle.COMPILE_THRESHOLD=3 \
    2.20 +#    -Djava.lang.invoke.MethodHandle.DUMP_CLASS_FILES=true \
    2.21 +#    -Djava.lang.invoke.MethodHandle.TRACE_METHOD_LINKAGE=true \
    2.22 +#    -Djava.lang.invoke.MethodHandle.TRACE_INTERPRETER=true"
    2.23  
    2.24  # Flags to run trusted tests from the Nashorn test suite
    2.25 -#FLAGS="-Djava.security.manager -Djava.security.policy=../build/nashorn.policy -Dnashorn.debug"
    2.26 +#
    2.27 +#TRUSTED_TEST_FLAGS="\
    2.28 +#-Djava.security.manager \
    2.29 +#-Djava.security.policy=../build/nashorn.policy -Dnashorn.debug"
    2.30  
    2.31 +# Testing out new code optimizations using the generic hotspot "new code" parameter
    2.32 +#
    2.33 +#USE_NEW_CODE_FLAGS=-XX:+UnlockDiagnosticVMOptions -XX:+UseNewCode
    2.34 +
    2.35 +#
    2.36 +#-Dnashorn.typeInfo.disabled=false \
    2.37 +# and for Nashorn options: 
    2.38 +# --class-cache-size=0 --persistent-code-cache=false 
    2.39  
    2.40  # Unique timestamped file name for JFR recordings. For JFR, we also have to
    2.41  # crank up the stack cutoff depth to 1024, because of ridiculously long lambda form
    2.42 @@ -46,8 +67,42 @@
    2.43  # can go (10 ms on most platforms). The default is normally higher. The increased
    2.44  # sampling overhead is usually negligible for Nashorn runs, but the data is better
    2.45  
    2.46 -JFR_FILENAME="./nashorn_$(date|sed "s/ /_/g"|sed "s/:/_/g").jfr"
    2.47 +if [ -z $JFR_FILENAME ]; then
    2.48 +    JFR_FILENAME="./nashorn_$(date|sed "s/ /_/g"|sed "s/:/_/g").jfr"
    2.49 +fi
    2.50  
    2.51 +# Flight recorder
    2.52 +#
    2.53 +# see above - already in place, copy the flags down here to disable
    2.54 +ENABLE_FLIGHT_RECORDER_FLAGS="\
    2.55 +    -XX:+UnlockCommercialFeatures \
    2.56 +    -XX:+FlightRecorder \
    2.57 +    -XX:FlightRecorderOptions=defaultrecording=true,disk=true,dumponexit=true,dumponexitpath=$JFR_FILENAME,stackdepth=1024"
    2.58 +
    2.59 +# Type specialization and math intrinsic replacement should be enabled by default in 8u20 and nine,
    2.60 +# keeping this flag around for experimental reasons. Replace + with - to switch it off
    2.61 +#
    2.62 +#ENABLE_TYPE_SPECIALIZATION_FLAGS=-XX:+UseTypeSpeculation
    2.63 +
    2.64 +# Same with math intrinsics. They should be enabled by default in 8u20 and 9, so
    2.65 +# this disables them if needed
    2.66 +#
    2.67 +#DISABLE_MATH_INTRINSICS_FLAGS=-XX:-UseMathExactIntrinsics
    2.68 +
    2.69 +# Add timing to time the compilation phases.
    2.70 +#ENABLE_TIME_FLAGS=--log=time
    2.71 +
    2.72 +# Add ShowHiddenFrames to get lambda form internals on the stack traces
    2.73 +#ENABLE_SHOW_HIDDEN_FRAMES_FLAGS=-XX:+ShowHiddenFrames
    2.74 +
    2.75 +# Add print optoassembly to get an asm dump. This requires 1) a debug build, not product,
    2.76 +# That tired compilation is switched off, for C2 only output and that the number of
    2.77 +# compiler threads is set to 1 for determinsm.
    2.78 +#
    2.79 +#PRINT_ASM_FLAGS=-XX:+PrintOptoAssembly -XX:-TieredCompilation -XX:CICompilerCount=1 \
    2.80 +
    2.81 +# Tier compile threasholds. Default value is 10. (1-100 is useful for experiments)
    2.82 +#TIER_COMPILATION_THRESHOLD_FLAGS=-XX:IncreaseFirstTierCompileThresholdAt=10
    2.83  
    2.84  # Directory where to look for nashorn.jar in a dist folder. The default is "..", assuming
    2.85  # that we run the script from the make dir
    2.86 @@ -59,49 +114,23 @@
    2.87  # nashorn.jar in $JAVA_HOME/jre/lib/ext. Thus, we also need -esa, as assertions in
    2.88  # nashorn count as system assertions in this configuration
    2.89  
    2.90 +# Type profiling default level is 111, 222 adds some compile time, but is faster
    2.91 +
    2.92  $JAVA_HOME/bin/java \
    2.93 -$FLAGS \
    2.94 --ea \
    2.95 --esa \
    2.96 +$ENABLE_ASSERTIONS_FLAGS \
    2.97 +$LAMBDAFORM_FLAGS \
    2.98 +$TRUSTED_FLAGS \
    2.99 +$USE_NEW_CODE_FLAGS \
   2.100 +$ENABLE_SHOW_HIDDEN_FRAMES_FLAGS \
   2.101 +$ENABLE_FLIGHT_RECORDER_FLAGS \
   2.102 +$ENABLE_TYPE_SPECIALIZATION_FLAGS \
   2.103 +$TIERED_COMPILATION_THRESOLD_FLAGS \
   2.104 +$DISABLE_MATH_INTRINSICS_FLAGS \
   2.105 +$PRINT_ASM_FLAGS \
   2.106  -Xbootclasspath/p:$NASHORN_JAR \
   2.107  -Xms2G -Xmx2G \
   2.108 +-XX:TypeProfileLevel=222 \
   2.109  -cp $CLASSPATH:../build/test/classes/ \
   2.110 -jdk.nashorn.tools.Shell ${@}
   2.111 +jdk.nashorn.tools.Shell $ENABLE_TIME_FLAGS ${@}
   2.112  
   2.113 -# Below are flags that may come in handy, but aren't used for default runs
   2.114  
   2.115 -
   2.116 -# Type profiling default level is 111, 222 adds some compile time, but produces better code.
   2.117 -# -XX:TypeProfileLevel=222 \
   2.118 -
   2.119 -
   2.120 -# Testing out new code optimizations using the generic hotspot "new code" parameter
   2.121 -#-XX:+UnlockDiagnosticVMOptions \
   2.122 -#-XX:+UseNewCode \
   2.123 -
   2.124 -
   2.125 -# Type specialization and math intrinsic replacement should be enabled by default in 8u20 and nine,
   2.126 -# keeping this flag around for experimental reasons. Replace + with - to switch it off
   2.127 -#-XX:+UseTypeSpeculation \
   2.128 -
   2.129 -
   2.130 -# Same with math intrinsics. They should be enabled by default in 8u20 and 9
   2.131 -#-XX:+UseMathExactIntrinsics \
   2.132 -
   2.133 -
   2.134 -# Add -Dnashorn.time to time the compilation phases.
   2.135 -#-Dnashorn.time \
   2.136 -
   2.137 -
   2.138 -# Add ShowHiddenFrames to get lambda form internals on the stack traces
   2.139 -#-XX:+ShowHiddenFrames \
   2.140 -
   2.141 -
   2.142 -# Add print optoassembly to get an asm dump. This requires 1) a debug build, not product,
   2.143 -# That tired compilation is switched off, for C2 only output and that the number of
   2.144 -# compiler threads is set to 1 for determinsm.
   2.145 -#-XX:+PrintOptoAssembly -XX:-TieredCompilation -XX:CICompilerCount=1 \
   2.146 -
   2.147 -# Tier compile threasholds. Default value is 10. (1-100 is useful for experiments)
   2.148 -# -XX:IncreaseFirstTierCompileThresholdAt=XX
   2.149 -

     3.1 --- a/docs/DEVELOPER_README	Mon Oct 27 14:36:13 2014 -0700
     3.2 +++ b/docs/DEVELOPER_README	Thu Nov 06 09:50:15 2014 -0800
     3.3 @@ -25,6 +25,14 @@
     3.4  > java -Dnashorn.args="--lazy-complation --log=compiler" large-java-app-with-nashorn.jar 
     3.5  > ant -Dnashorn.args="--log=codegen" antjob
     3.6  
     3.7 +SYSTEM PROPERTY: -Dnashorn.args.prepend=<string>
     3.8 +
     3.9 +This property behaves like nashorn.args, but adds the given arguments
    3.10 +before the existing ones instead of after them. Later arguments will
    3.11 +overwrite earlier ones, so this is useful for setting default arguments
    3.12 +that can be overwritten.
    3.13 +
    3.14 +
    3.15  SYSTEM PROPERTY: -Dnashorn.unstable.relink.threshold=x
    3.16  
    3.17  This property controls how many call site misses are allowed before a 
    3.18 @@ -42,533 +50,38 @@
    3.19  The default value is 0x8000 (32768).
    3.20  
    3.21  
    3.22 -SYSTEM PROPERTY: -Dnashorn.compiler.intarithmetic
    3.23 +SYSTEM PROPERTY: -Dnashorn.serialize.compression=<x>
    3.24  
    3.25 -(and integer arithmetic in general)
    3.26 +This property sets the compression level used when deflating serialized
    3.27 +AST structures of anonymous split functions. Valid values range from 0 to 9,
    3.28 +the default value is 4. Higher values will reduce memory size of serialized
    3.29 +AST but increase CPU usage required for compression.
    3.30  
    3.31 -<currently disabled - this is being refactored for update releases> 
    3.32  
    3.33 -Arithmetic operations in Nashorn (except bitwise ones) typically
    3.34 -coerce the operands to doubles (as per the JavaScript spec). To switch
    3.35 -this off and remain in integer mode, for example for "var x = a&b; var
    3.36 -y = c&d; var z = x*y;", use this flag. This will force the
    3.37 -multiplication of variables that are ints to be done with the IMUL
    3.38 -bytecode and the result "z" to become an int.
    3.39 -
    3.40 -WARNING: Note that is is experimental only to ensure that type support
    3.41 -exists for all primitive types. The generated code is unsound. This
    3.42 -will be the case until we do optimizations based on it. There is a CR
    3.43 -in Nashorn to do better range analysis, and ensure that this is only
    3.44 -done where the operation can't overflow into a wider type. Currently
    3.45 -no overflow checking is done, so at the moment, until range analysis
    3.46 -has been completed, this option is turned off.
    3.47 -
    3.48 -We've experimented by using int arithmetic for everything and putting
    3.49 -overflow checks afterwards, which would recompute the operation with
    3.50 -the correct precision, but have yet to find a configuration where this
    3.51 -is faster than just using doubles directly, even if the int operation
    3.52 -does not overflow. Getting access to a JVM intrinsic that does branch
    3.53 -on overflow would probably alleviate this.
    3.54 -
    3.55 -The future:
    3.56 -
    3.57 -We are transitioning to an optimistic type system that uses int
    3.58 -arithmetic everywhere until proven wrong. The problem here is mostly
    3.59 -catch an overflow exception and rolling back the state to a new method
    3.60 -with less optimistic assumptions for an operation at a particular
    3.61 -program point. This will most likely not be in the Java 8.0 release
    3.62 -but likely end up in an update release
    3.63 -
    3.64 -For Java 8, several java.lang.Math methods like addExact, subExact and
    3.65 -mulExact are available to help us. Experiments intrinsifying these
    3.66 -show a lot of promise, and we have devised a system that basically
    3.67 -does on stack replacement with exceptions in bytecode to revert
    3.68 -erroneous assumptions. An explanation of how this works and what we
    3.69 -are doing can be found here:
    3.70 -http://www.slideshare.net/lagergren/lagergren-jvmls2013final
    3.71 -
    3.72 -Experiments with this show significant ~x2-3 performance increases on
    3.73 -pretty much everything, provided that optimistic assumptions don't
    3.74 -fail much. It will affect warmup time negatively, depending on how
    3.75 -many erroneous too optimistic assumptions are placed in the code at
    3.76 -compile time. We don't think this will be much of an issue.
    3.77 -
    3.78 -For example for a small benchmark that repeatedly executes this
    3.79 -method taken from the Crypto Octane benchmark 
    3.80 -
    3.81 -function am3(i,x,w,j,c,n) {
    3.82 -  var this_array = this.array;
    3.83 -  var w_array    = w.array;
    3.84 -  var xl = x&0x3fff, xh = x>>14;
    3.85 -  while(--n >= 0) {
    3.86 -    var l = this_array[i]&0x3fff;
    3.87 -    var h = this_array[i++]>>14;
    3.88 -    var m = xh*l+h*xl;
    3.89 -    l = xl*l+((m&0x3fff)<<14)+w_array[j]+c;
    3.90 -    c = (l>>28)+(m>>14)+xh*h;
    3.91 -    w_array[j++] = l&0xfffffff;
    3.92 -  }
    3.93 -
    3.94 -  return c;
    3.95 -}
    3.96 -
    3.97 -The performance increase more than doubles. We are also working hard
    3.98 -with the code generation team in the Java Virtual Machine to fix
    3.99 -things that are lacking in invokedynamic performance, which is another
   3.100 -area where a lot of ongoing performance work takes place
   3.101 -
   3.102 -"Pessimistic" bytecode for am3, guaranteed to be semantically correct:
   3.103 -
   3.104 -// access flags 0x9
   3.105 -  public static am3(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
   3.106 -   L0
   3.107 -    LINENUMBER 12 L0
   3.108 -    ALOAD 0
   3.109 -    INVOKEDYNAMIC dyn:getProp|getElem|getMethod:array(Ljava/lang/Object;)Ljava/lang/Object; [
   3.110 -      // handle kind 0x6 : INVOKESTATIC
   3.111 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.112 -      // arguments:
   3.113 -      0
   3.114 -    ]
   3.115 -    ASTORE 8
   3.116 -   L1
   3.117 -    LINENUMBER 13 L1
   3.118 -    ALOAD 3
   3.119 -    INVOKEDYNAMIC dyn:getProp|getElem|getMethod:array(Ljava/lang/Object;)Ljava/lang/Object; [
   3.120 -      // handle kind 0x6 : INVOKESTATIC
   3.121 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.122 -      // arguments:
   3.123 -      0
   3.124 -    ]
   3.125 -    ASTORE 9
   3.126 -   L2
   3.127 -    LINENUMBER 14 L2
   3.128 -    ALOAD 2
   3.129 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toInt32 (Ljava/lang/Object;)I
   3.130 -    SIPUSH 16383
   3.131 -    IAND
   3.132 -    ISTORE 10
   3.133 -    ALOAD 2
   3.134 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toInt32 (Ljava/lang/Object;)I
   3.135 -    BIPUSH 14
   3.136 -    ISHR
   3.137 -    ISTORE 11
   3.138 -   L3
   3.139 -    LINENUMBER 15 L3
   3.140 -    GOTO L4
   3.141 -   L5
   3.142 -    LINENUMBER 16 L5
   3.143 -   FRAME FULL [java/lang/Object java/lang/Object java/lang/Object java/lang/Object java/lang/Object java/lang/Object java/lang/Double T java/lang/Object java/lang/Object I I] []
   3.144 -    ALOAD 8
   3.145 -    ALOAD 1
   3.146 -    INVOKEDYNAMIC dyn:getElem|getProp|getMethod(Ljava/lang/Object;Ljava/lang/Object;)I [
   3.147 -      // handle kind 0x6 : INVOKESTATIC
   3.148 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.149 -      // arguments:
   3.150 -      0
   3.151 -    ]
   3.152 -    SIPUSH 16383
   3.153 -    IAND
   3.154 -    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
   3.155 -    ASTORE 12
   3.156 -   L6
   3.157 -    LINENUMBER 17 L6
   3.158 -    ALOAD 8
   3.159 -    ALOAD 1
   3.160 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toNumber (Ljava/lang/Object;)D
   3.161 -    DUP2
   3.162 -    DCONST_1
   3.163 -    DADD
   3.164 -    INVOKESTATIC java/lang/Double.valueOf (D)Ljava/lang/Double;
   3.165 -    ASTORE 1
   3.166 -    INVOKEDYNAMIC dyn:getElem|getProp|getMethod(Ljava/lang/Object;D)I [
   3.167 -      // handle kind 0x6 : INVOKESTATIC
   3.168 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.169 -      // arguments:
   3.170 -      0
   3.171 -    ]
   3.172 -    BIPUSH 14
   3.173 -    ISHR
   3.174 -    ISTORE 13
   3.175 -   L7
   3.176 -    LINENUMBER 18 L7
   3.177 -    ILOAD 11
   3.178 -    I2D
   3.179 -    ALOAD 12
   3.180 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toNumber (Ljava/lang/Object;)D
   3.181 -    DMUL
   3.182 -    ILOAD 13
   3.183 -    I2D
   3.184 -    ILOAD 10
   3.185 -    I2D
   3.186 -    DMUL
   3.187 -    DADD
   3.188 -    DSTORE 14
   3.189 -   L8
   3.190 -    LINENUMBER 19 L8
   3.191 -    ILOAD 10
   3.192 -    I2D
   3.193 -    ALOAD 12
   3.194 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toNumber (Ljava/lang/Object;)D
   3.195 -    DMUL
   3.196 -    DLOAD 14
   3.197 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toInt32 (D)I
   3.198 -    SIPUSH 16383
   3.199 -    IAND
   3.200 -    BIPUSH 14
   3.201 -    ISHL
   3.202 -    I2D
   3.203 -    DADD
   3.204 -    ALOAD 9
   3.205 -    ALOAD 4
   3.206 -    INVOKEDYNAMIC dyn:getElem|getProp|getMethod(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; [
   3.207 -      // handle kind 0x6 : INVOKESTATIC
   3.208 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.209 -      // arguments:
   3.210 -      0
   3.211 -    ]
   3.212 -    INVOKEDYNAMIC ADD:ODO_D(DLjava/lang/Object;)Ljava/lang/Object; [
   3.213 -      // handle kind 0x6 : INVOKESTATIC
   3.214 -      jdk/nashorn/internal/runtime/linker/Bootstrap.runtimeBootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;)
   3.215 -      // arguments: none
   3.216 -    ]
   3.217 -    ALOAD 5
   3.218 -    INVOKEDYNAMIC ADD:OOO_I(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; [
   3.219 -      // handle kind 0x6 : INVOKESTATIC
   3.220 -      jdk/nashorn/internal/runtime/linker/Bootstrap.runtimeBootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;)
   3.221 -      // arguments: none
   3.222 -    ]
   3.223 -    ASTORE 12
   3.224 -   L9
   3.225 -    LINENUMBER 20 L9
   3.226 -    ALOAD 12
   3.227 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toInt32 (Ljava/lang/Object;)I
   3.228 -    BIPUSH 28
   3.229 -    ISHR
   3.230 -    I2D
   3.231 -    DLOAD 14
   3.232 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toInt32 (D)I
   3.233 -    BIPUSH 14
   3.234 -    ISHR
   3.235 -    I2D
   3.236 -    DADD
   3.237 -    ILOAD 11
   3.238 -    I2D
   3.239 -    ILOAD 13
   3.240 -    I2D
   3.241 -    DMUL
   3.242 -    DADD
   3.243 -    INVOKESTATIC java/lang/Double.valueOf (D)Ljava/lang/Double;
   3.244 -    ASTORE 5
   3.245 -   L10
   3.246 -    LINENUMBER 21 L10
   3.247 -    ALOAD 9
   3.248 -    ALOAD 4
   3.249 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toNumber (Ljava/lang/Object;)D
   3.250 -    DUP2
   3.251 -    DCONST_1
   3.252 -    DADD
   3.253 -    INVOKESTATIC java/lang/Double.valueOf (D)Ljava/lang/Double;
   3.254 -    ASTORE 4
   3.255 -    ALOAD 12
   3.256 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toInt32 (Ljava/lang/Object;)I
   3.257 -    LDC 268435455
   3.258 -    IAND
   3.259 -    INVOKEDYNAMIC dyn:setElem|setProp(Ljava/lang/Object;DI)V [
   3.260 -      // handle kind 0x6 : INVOKESTATIC
   3.261 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.262 -      // arguments:
   3.263 -      0
   3.264 -    ]
   3.265 -   L4
   3.266 -   FRAME FULL [java/lang/Object java/lang/Object java/lang/Object java/lang/Object java/lang/Object java/lang/Object java/lang/Object T java/lang/Object java/lang/Object I I] []
   3.267 -    ALOAD 6
   3.268 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.toNumber (Ljava/lang/Object;)D
   3.269 -    LDC -1.0
   3.270 -    DADD
   3.271 -    DUP2
   3.272 -    INVOKESTATIC java/lang/Double.valueOf (D)Ljava/lang/Double;
   3.273 -    ASTORE 6
   3.274 -    DCONST_0
   3.275 -    DCMPL
   3.276 -    IFGE L5
   3.277 -   L11
   3.278 -    LINENUMBER 24 L11
   3.279 -    ALOAD 5
   3.280 -    ARETURN
   3.281 -
   3.282 -"Optimistic" bytecode that requires invalidation on e.g overflow. Factor
   3.283 -x2-3 speedup:
   3.284 -
   3.285 -public static am3(Ljava/lang/Object;IILjava/lang/Object;III)I
   3.286 -   L0
   3.287 -    LINENUMBER 12 L0
   3.288 -    ALOAD 0
   3.289 -    INVOKEDYNAMIC dyn:getProp|getElem|getMethod:array(Ljava/lang/Object;)Ljava/lang/Object; [
   3.290 -      // handle kind 0x6 : INVOKESTATIC
   3.291 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.292 -      // arguments:
   3.293 -      0
   3.294 -    ]
   3.295 -    ASTORE 8
   3.296 -   L1
   3.297 -    LINENUMBER 13 L1
   3.298 -    ALOAD 3
   3.299 -    INVOKEDYNAMIC dyn:getProp|getElem|getMethod:array(Ljava/lang/Object;)Ljava/lang/Object; [
   3.300 -      // handle kind 0x6 : INVOKESTATIC
   3.301 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.302 -      // arguments:
   3.303 -      0
   3.304 -    ]
   3.305 -    ASTORE 9
   3.306 -   L2
   3.307 -    LINENUMBER 14 L2
   3.308 -    ILOAD 2
   3.309 -    SIPUSH 16383
   3.310 -    IAND
   3.311 -    ISTORE 10
   3.312 -    ILOAD 2
   3.313 -    BIPUSH 14
   3.314 -    ISHR
   3.315 -    ISTORE 11
   3.316 -   L3
   3.317 -    LINENUMBER 15 L3
   3.318 -    GOTO L4
   3.319 -   L5
   3.320 -    LINENUMBER 16 L5
   3.321 -   FRAME FULL [java/lang/Object I I java/lang/Object I I I T java/lang/Object java/lang/Object I I] []
   3.322 -    ALOAD 8
   3.323 -    ILOAD 1
   3.324 -    INVOKEDYNAMIC dyn:getElem|getProp|getMethod(Ljava/lang/Object;I)I [
   3.325 -      // handle kind 0x6 : INVOKESTATIC
   3.326 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.327 -      // arguments:
   3.328 -      0
   3.329 -    ]
   3.330 -    SIPUSH 16383
   3.331 -    IAND
   3.332 -    ISTORE 12
   3.333 -   L6
   3.334 -    LINENUMBER 17 L6
   3.335 -    ALOAD 8
   3.336 -    ILOAD 1
   3.337 -    DUP
   3.338 -    ICONST_1
   3.339 -    IADD
   3.340 -    ISTORE 1
   3.341 -    INVOKEDYNAMIC dyn:getElem|getProp|getMethod(Ljava/lang/Object;I)I [
   3.342 -      // handle kind 0x6 : INVOKESTATIC
   3.343 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.344 -      // arguments:
   3.345 -      0
   3.346 -    ]
   3.347 -    BIPUSH 14
   3.348 -    ISHR
   3.349 -    ISTORE 13
   3.350 -   L7
   3.351 -    LINENUMBER 18 L7
   3.352 -    ILOAD 11
   3.353 -    ILOAD 12
   3.354 -    BIPUSH 8
   3.355 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.mulExact (III)I
   3.356 -    ILOAD 13
   3.357 -    ILOAD 10
   3.358 -    BIPUSH 9
   3.359 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.mulExact (III)I
   3.360 -    IADD
   3.361 -    ISTORE 14
   3.362 -   L8
   3.363 -    LINENUMBER 19 L8
   3.364 -    ILOAD 10
   3.365 -    ILOAD 12
   3.366 -    BIPUSH 11
   3.367 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.mulExact (III)I
   3.368 -    ILOAD 14
   3.369 -    SIPUSH 16383
   3.370 -    IAND
   3.371 -    BIPUSH 14
   3.372 -    ISHL
   3.373 -    IADD
   3.374 -    ALOAD 9
   3.375 -    ILOAD 4
   3.376 -    INVOKEDYNAMIC dyn:getElem|getProp|getMethod(Ljava/lang/Object;I)I [
   3.377 -      // handle kind 0x6 : INVOKESTATIC
   3.378 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.379 -      // arguments:
   3.380 -      0
   3.381 -    ]
   3.382 -    IADD
   3.383 -    ILOAD 5
   3.384 -    IADD
   3.385 -    ISTORE 12
   3.386 -   L9
   3.387 -    LINENUMBER 20 L9
   3.388 -    ILOAD 12
   3.389 -    BIPUSH 28
   3.390 -    ISHR
   3.391 -    ILOAD 14
   3.392 -    BIPUSH 14
   3.393 -    ISHR
   3.394 -    IADD
   3.395 -    ILOAD 11
   3.396 -    ILOAD 13
   3.397 -    BIPUSH 21
   3.398 -    INVOKESTATIC jdk/nashorn/internal/runtime/JSType.mulExact (III)I
   3.399 -    IADD
   3.400 -    ISTORE 5
   3.401 -   L10
   3.402 -    LINENUMBER 21 L10
   3.403 -    ALOAD 9
   3.404 -    ILOAD 4
   3.405 -    DUP
   3.406 -    ICONST_1
   3.407 -    IADD
   3.408 -    ISTORE 4
   3.409 -    ILOAD 12
   3.410 -    LDC 268435455
   3.411 -    IAND
   3.412 -    INVOKEDYNAMIC dyn:setElem|setProp(Ljava/lang/Object;II)V [
   3.413 -      // handle kind 0x6 : INVOKESTATIC
   3.414 -      jdk/nashorn/internal/runtime/linker/Bootstrap.bootstrap((Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;I)Ljava/lang/invoke/CallSite;)
   3.415 -      // arguments:
   3.416 -      0
   3.417 -    ]
   3.418 -   L4
   3.419 -   FRAME SAME
   3.420 -    ILOAD 6
   3.421 -    ICONST_M1
   3.422 -    IADD
   3.423 -    DUP
   3.424 -    ISTORE 6
   3.425 -    ICONST_0
   3.426 -    IF_ICMPGE L5
   3.427 -   L11
   3.428 -    LINENUMBER 24 L11
   3.429 -    ILOAD 5
   3.430 -    IRETURN
   3.431 -
   3.432 -
   3.433 -SYSTEM PROPERTY: -Dnashorn.codegen.debug, -Dnashorn.codegen.debug.trace=<x>
   3.434 +SYSTEM PROPERTY: -Dnashorn.codegen.debug.trace=<x>
   3.435  
   3.436  See the description of the codegen logger below.
   3.437  
   3.438  
   3.439 -SYSTEM_PROPERTY: -Dnashorn.fields.debug
   3.440 +SYSTEM PROPERTY: -Dnashorn.fields.objects
   3.441  
   3.442 -See the description on the fields logger below.
   3.443 +When this property is true, Nashorn will only use object fields for
   3.444 +AccessorProperties. This means that primitive values must be boxed
   3.445 +when stored in a field, which is significantly slower than using
   3.446 +primitive fields.
   3.447  
   3.448 -
   3.449 -SYSTEM PROPERTY: -Dnashorn.fields.dual
   3.450 -
   3.451 -When this property is true, Nashorn will attempt to use primitive
   3.452 -fields for AccessorProperties (currently just AccessorProperties, not
   3.453 -spill properties). Memory footprint for script objects will increase,
   3.454 -as we need to maintain both a primitive field (a long) as well as an
   3.455 -Object field for the property value. Ints are represented as the 32
   3.456 -low bits of the long fields. Doubles are represented as the
   3.457 -doubleToLongBits of their value. This way a single field can be used
   3.458 -for all primitive types. Packing and unpacking doubles to their bit
   3.459 -representation is intrinsified by the JVM and extremely fast.
   3.460 -
   3.461 -While dual fields in theory runs significantly faster than Object
   3.462 -fields due to reduction of boxing and memory allocation overhead,
   3.463 -there is still work to be done to make this a general purpose
   3.464 -solution. Research is ongoing.
   3.465 +By default, Nashorn uses dual object and long fields. Ints are
   3.466 +represented as the 32 low bits of the long fields. Doubles are
   3.467 +represented as the doubleToLongBits of their value. This way a
   3.468 +single field can be used for all primitive types. Packing and
   3.469 +unpacking doubles to their bit representation is intrinsified by
   3.470 +the JVM and extremely fast.
   3.471  
   3.472  In the future, this might complement or be replaced by experimental
   3.473  feature sun.misc.TaggedArray, which has been discussed on the mlvm
   3.474  mailing list. TaggedArrays are basically a way to share data space
   3.475  between primitives and references, and have the GC understand this.
   3.476  
   3.477 -As long as only primitive values are written to the fields and enough
   3.478 -type information exists to make sure that any reads don't have to be
   3.479 -uselessly boxed and unboxed, this is significantly faster than the
   3.480 -standard "Objects only" approach that currently is the default. See
   3.481 -test/examples/dual-fields-micro.js for an example that runs twice as
   3.482 -fast with dual fields as without them. Here, the compiler, can
   3.483 -determine that we are dealing with numbers only throughout the entire
   3.484 -property life span of the properties involved.
   3.485 -
   3.486 -If a "real" object (not a boxed primitive) is written to a field that
   3.487 -has a primitive representation, its callsite is relinked and an Object
   3.488 -field is used forevermore for that particular field in that
   3.489 -PropertyMap and its children, even if primitives are later assigned to
   3.490 -it.
   3.491 -
   3.492 -As the amount of compile time type information is very small in a
   3.493 -dynamic language like JavaScript, it is frequently the case that
   3.494 -something has to be treated as an object, because we don't know any
   3.495 -better. In reality though, it is often a boxed primitive is stored to
   3.496 -an AccessorProperty. The fastest way to handle this soundly is to use
   3.497 -a callsite typecheck and avoid blowing the field up to an Object. We
   3.498 -never revert object fields to primitives. Ping-pong:ing back and forth
   3.499 -between primitive representation and Object representation would cause
   3.500 -fatal performance overhead, so this is not an option.
   3.501 -
   3.502 -For a general application the dual fields approach is still slower
   3.503 -than objects only fields in some places, about the same in most cases,
   3.504 -and significantly faster in very few. This is due the program using
   3.505 -primitives, but we still can't prove it. For example "local_var a =
   3.506 -call(); field = a;" may very well write a double to the field, but the
   3.507 -compiler dare not guess a double type if field is a local variable,
   3.508 -due to bytecode variables being strongly typed and later non
   3.509 -interchangeable. To get around this, the entire method would have to
   3.510 -be replaced and a continuation retained to restart from. We believe
   3.511 -that the next steps we should go through are instead:
   3.512 -
   3.513 -1) Implement method specialization based on callsite, as it's quite
   3.514 -frequently the case that numbers are passed around, but currently our
   3.515 -function nodes just have object types visible to the compiler. For
   3.516 -example "var b = 17; func(a,b,17)" is an example where two parameters
   3.517 -can be specialized, but the main version of func might also be called
   3.518 -from another callsite with func(x,y,"string").
   3.519 -
   3.520 -2) This requires lazy jitting as the functions have to be specialized
   3.521 -per callsite.
   3.522 -
   3.523 -Even though "function square(x) { return x*x }" might look like a
   3.524 -trivial function that can always only take doubles, this is not
   3.525 -true. Someone might have overridden the valueOf for x so that the
   3.526 -toNumber coercion has side effects. To fulfil JavaScript semantics,
   3.527 -the coercion has to run twice for both terms of the multiplication
   3.528 -even if they are the same object. This means that call site
   3.529 -specialization is necessary, not parameter specialization on the form
   3.530 -"function square(x) { var xd = (double)x; return xd*xd; }", as one
   3.531 -might first think.
   3.532 -
   3.533 -Generating a method specialization for any variant of a function that
   3.534 -we can determine by types at compile time is a combinatorial explosion
   3.535 -of byte code (try it e.g. on all the variants of am3 in the Octane
   3.536 -benchmark crypto.js). Thus, this needs to be lazy
   3.537 -
   3.538 -3) Optimistic callsite writes, something on the form
   3.539 -
   3.540 -x = y; //x is a field known to be a primitive. y is only an object as
   3.541 -far as we can tell
   3.542 -
   3.543 -turns into
   3.544 -
   3.545 -try {
   3.546 -  x = (int)y;
   3.547 -} catch (X is not an integer field right now | ClassCastException e) {
   3.548 -  x = y;
   3.549 -}
   3.550 -
   3.551 -Mini POC shows that this is the key to a lot of dual field performance
   3.552 -in seemingly trivial micros where one unknown object, in reality
   3.553 -actually a primitive, foils it for us. Very common pattern. Once we
   3.554 -are "all primitives", dual fields runs a lot faster than Object fields
   3.555 -only.
   3.556 -
   3.557 -We still have to deal with objects vs primitives for local bytecode
   3.558 -slots, possibly through code copying and versioning.
   3.559 -
   3.560 -The Future:
   3.561 -
   3.562 -We expect the usefulness of dual fields to increase significantly
   3.563 -after the optimistic type system described in the section on 
   3.564 -integer arithmetic above is implemented.
   3.565 -
   3.566  
   3.567  SYSTEM PROPERTY: -Dnashorn.compiler.symbol.trace=[<x>[,*]], 
   3.568    -Dnashorn.compiler.symbol.stacktrace=[<x>[,*]]
   3.569 @@ -628,6 +141,9 @@
   3.570  "identical" - this method compares two script objects for reference
   3.571  equality. It is a == Java comparison
   3.572  
   3.573 +"equals" - Returns true if two objects are either referentially
   3.574 +identical or equal as defined by java.lang.Object.equals.
   3.575 +
   3.576  "dumpCounters" - will dump the debug counters' current values to
   3.577  stdout.
   3.578  
   3.579 @@ -648,66 +164,66 @@
   3.580  when a callsite has to be relinked, due to a previous assumption of
   3.581  object layout being invalidated.
   3.582  
   3.583 +"getContext" - return the current Nashorn context.
   3.584  
   3.585 -SYSTEM PROPERTY: -Dnashorn.methodhandles.debug,
   3.586 --Dnashorn.methodhandles.debug=create
   3.587 +"equalWithoutType" - Returns true if if the two objects are both
   3.588 +property maps, and they have identical properties in the same order,
   3.589 +but allows the properties to differ in their types.
   3.590  
   3.591 -If this property is enabled, each MethodHandle related call that uses
   3.592 -the java.lang.invoke package gets its MethodHandle intercepted and an
   3.593 -instrumentation printout of arguments and return value appended to
   3.594 -it. This shows exactly which method handles are executed and from
   3.595 -where. (Also MethodTypes and SwitchPoints). This can be augmented with
   3.596 -more information, for example, instance count, by subclassing or
   3.597 -further extending the TraceMethodHandleFactory implementation in
   3.598 -MethodHandleFactory.java.
   3.599 +"diffPropertyMaps" Returns a diagnostic string representing the difference
   3.600 +of two property maps.
   3.601  
   3.602 -If the property is specialized with "=create" as its option,
   3.603 -instrumentation will be shown for method handles upon creation time
   3.604 -rather than at runtime usage.
   3.605 +"getClass" - Returns the Java class of an object, or undefined if null.
   3.606 +
   3.607 +"toJavaString" - Returns the Java toString representation of an object.
   3.608 +
   3.609 +"toIdentString" - Returns a string representation of an object consisting
   3.610 +of its java class name and hash code.
   3.611 +
   3.612 +"getListenerCount" - Return the number of property listeners for a
   3.613 +script object.
   3.614 +
   3.615 +"getEventQueueCapacity" - Get the capacity of the event queue.
   3.616 +
   3.617 +"setEventQueueCapacity" - Set the event queue capacity.
   3.618 +
   3.619 +"addRuntimeEvent" - Add a runtime event to the runtime event queue.
   3.620 +The queue has a fixed size (see -Dnashorn.runtime.event.queue.size)
   3.621 +and the oldest entry will be thrown out of the queue is about to overflow.
   3.622 +
   3.623 +"expandEventQueueCapacity" - Expands the event queue capacity,
   3.624 +or truncates if capacity is lower than current capacity. Then only
   3.625 +the newest entries are kept.
   3.626 +
   3.627 +"clearRuntimeEvents" - Clear the runtime event queue.
   3.628 +
   3.629 +"removeRuntimeEvent" - Remove a specific runtime event from the event queue.
   3.630 +
   3.631 +"getRuntimeEvents" - Return all runtime events in the queue as an array.
   3.632 +
   3.633 +"getLastRuntimeEvent" - Return the last runtime event in the queue.
   3.634  
   3.635  
   3.636  SYSTEM PROPERTY: -Dnashorn.methodhandles.debug.stacktrace
   3.637  
   3.638 -This does the same as nashorn.methodhandles.debug, but when enabled
   3.639 -also dumps the stack trace for every instrumented method handle
   3.640 -operation. Warning: This is enormously verbose, but provides a pretty
   3.641 +This enhances methodhandles logging (see below) to also dump the
   3.642 +stack trace for every instrumented method handle operation.
   3.643 +Warning: This is enormously verbose, but provides a pretty
   3.644  decent "grep:able" picture of where the calls are coming from.
   3.645  
   3.646 -See the description of the codegen logger below for a more verbose
   3.647 -description of this option
   3.648  
   3.649 +SYSTEM PROPERTY: -Dnashorn.cce
   3.650  
   3.651 -SYSTEM PROPERTY: -Dnashorn.scriptfunction.specialization.disable
   3.652 +Setting this system property causes the Nashorn linker to rely on
   3.653 +ClassCastExceptions for triggering a callsite relink. If not set, the linker
   3.654 +will add an explicit instanceof guard.
   3.655  
   3.656 -There are several "fast path" implementations of constructors and
   3.657 -functions in the NativeObject classes that, in their original form,
   3.658 -take a variable amount of arguments. Said functions are also declared
   3.659 -to take Object parameters in their original form, as this is what the
   3.660 -JavaScript specification mandates.
   3.661 -However, we often know quite a lot more at a callsite of one of these
   3.662 -functions. For example, Math.min is called with a fixed number (2) of
   3.663 -integer arguments. The overhead of boxing these ints to Objects and
   3.664 -folding them into an Object array for the generic varargs Math.min
   3.665 -function is an order of magnitude slower than calling a specialized
   3.666 -implementation of Math.min that takes two integers. Specialized
   3.667 -functions and constructors are identified by the tag
   3.668 -@SpecializedFunction and @SpecializedConstructor in the Nashorn
   3.669 -code. The linker will link in the most appropriate (narrowest types,
   3.670 -right number of types and least number of arguments) specialization if
   3.671 -specializations are available.
   3.672  
   3.673 -Every ScriptFunction may carry specializations that the linker can
   3.674 -choose from. This framework will likely be extended for user defined
   3.675 -functions. The compiler can often infer enough parameter type info
   3.676 -from callsites for in order to generate simpler versions with less
   3.677 -generic Object types. This feature depends on future lazy jitting, as
   3.678 -there tend to be many calls to user defined functions, some where the
   3.679 -callsite can be specialized, some where we mostly see object
   3.680 -parameters even at the callsite.
   3.681 +SYSTEM PROPERTY: -Dnashorn.spill.threshold=<x>
   3.682  
   3.683 -If this system property is set to true, the linker will not attempt to
   3.684 -use any specialized function or constructor for native objects, but
   3.685 -just call the generic one.
   3.686 +This property sets the number of fields in an object from which to use
   3.687 +generic array based spill storage instead of Java fields. The default value
   3.688 +is 256.
   3.689  
   3.690  
   3.691  SYSTEM PROPERTY: -Dnashorn.tcs.miss.samplePercent=<x>
   3.692 @@ -719,8 +235,47 @@
   3.693  should be logged. Typically this is set to 1 or 5 (percent). 1% is the
   3.694  default value.
   3.695  
   3.696 +SYSTEM PROPERTY: -Dnashorn.persistent.code.cache
   3.697  
   3.698 -SYSTEM_PROPERTY: -Dnashorn.profilefile=<filename>
   3.699 +This property can be used to set the directory where Nashorn stores
   3.700 +serialized script classes generated with the -pcc/--persistent-code-cache
   3.701 +option. The default directory name is "nashorn_code_cache".
   3.702 +
   3.703 +
   3.704 +SYSTEM PROPERTY: -Dnashorn.typeInfo.maxFiles
   3.705 +
   3.706 +Maximum number of files to store in the type info cache. The type info cache
   3.707 +is used to cache type data of JavaScript functions when running with
   3.708 +optimistic types (-ot/--optimistic-types). There is one file per JavaScript
   3.709 +function in the cache.
   3.710 +
   3.711 +The default value is 0 which means the feature is disabled. Setting this
   3.712 +to something like 20000 is probably good enough for most applications and
   3.713 +will usually cap the cache directory to about 80MB presuming a 4kB
   3.714 +filesystem allocation unit. Set this to "unlimited" to run without limit.
   3.715 +
   3.716 +If the value is not 0 or "unlimited", Nashorn will spawn a cleanup thread
   3.717 +that makes sure the number of files in the cache does not exceed the given
   3.718 +value by deleting the least recently modified files.
   3.719 +
   3.720 +
   3.721 +SYSTEM PROPERTY: -Dnashorn.typeInfo.cacheDir
   3.722 +
   3.723 +This property can be used to set the directory where Nashorn stores the
   3.724 +type info cache when -Dnashorn.typeInfo.maxFiles is set to a nonzero
   3.725 +value. The default location is platform specific. On Windows, it is
   3.726 +"${java.io.tmpdir}\com.oracle.java.NashornTypeInfo". On Linux and
   3.727 +Solaris it is "~/.cache/com.oracle.java.NashornTypeInfo". On Mac OS X,
   3.728 +it is "~/Library/Caches/com.oracle.java.NashornTypeInfo".
   3.729 +
   3.730 +
   3.731 +SYSTEM PROPERTY: -Dnashorn.typeInfo.cleanupDelaySeconds=<value>
   3.732 +
   3.733 +This sets the delay between cleanups of the typeInfo cache, in seconds.
   3.734 +The default delay is 20 seconds.
   3.735 +
   3.736 +
   3.737 +SYSTEM PROPERTY: -Dnashorn.profilefile=<filename>
   3.738  
   3.739  When running with the profile callsite options (-pcs), Nashorn will
   3.740  dump profiling data for all callsites to stderr as a shutdown hook. To
   3.741 @@ -736,6 +291,11 @@
   3.742  an implementation based on Joni, the regular expression engine used by
   3.743  the JRuby project. The default value for this flag is "joni"
   3.744  
   3.745 +SYSTEM PROPERTY: -Dnashorn.runtime.event.queue.size=<value>
   3.746 +
   3.747 +Nashorn provides a fixed sized runtime event queue for debugging purposes.
   3.748 +See -Dnashorn.debug for methods to access the event queue.
   3.749 +The default value is 1024.
   3.750  
   3.751  ===============
   3.752  2. The loggers.
   3.753 @@ -767,7 +327,9 @@
   3.754  For example: --log=codegen,fields:finest is equivalent to
   3.755  --log=codegen:info --log=fields:finest
   3.756  
   3.757 -The subsystems that currently support logging are:
   3.758 +The following is an incomplete list of subsystems that currently
   3.759 +support logging. Look for classes implementing
   3.760 +jdk.nashorn.internal.runtime.logging.Loggable for more loggers.
   3.761  
   3.762  
   3.763  * compiler
   3.764 @@ -780,6 +342,14 @@
   3.765  use.s
   3.766  
   3.767  
   3.768 +* recompile
   3.769 +
   3.770 +This logger shows information about recompilation of scripts and
   3.771 +functions at runtime. Recompilation may happen because a function
   3.772 +was called with different parameter types, or because an optimistic
   3.773 +assumption failed while executing a function with -ot/--optimistic-types.
   3.774 +
   3.775 +
   3.776  * codegen
   3.777  
   3.778  The code generator is the emitter stage of the code pipeline, and
   3.779 @@ -836,25 +406,13 @@
   3.780  Lower is also responsible for determining control flow information
   3.781  like end points.
   3.782  
   3.783 +* symbols
   3.784  
   3.785 -* attr
   3.786 +The symbols logger tracks the assignment os symbols to identifiers.
   3.787  
   3.788 -The lowering annotates a FunctionNode with symbols for each identifier
   3.789 -and transforms high level constructs into lower level ones, that the
   3.790 -CodeGenerator consumes.
   3.791 +* scopedepths
   3.792  
   3.793 -Lower logging typically outputs things like post pass actions,
   3.794 -insertions of casts because symbol types have been changed and type
   3.795 -specialization information. Currently very little info is generated by
   3.796 -this logger. This will probably change.
   3.797 -
   3.798 -
   3.799 -* finalize
   3.800 -
   3.801 -This --log=finalize log option outputs information for type finalization,
   3.802 -the third tier of the compiler. This means things like placement of 
   3.803 -specialized scope nodes or explicit conversions. 
   3.804 -
   3.805 +This logs the calculation of scope depths for non-local symbols.
   3.806  
   3.807  * fields
   3.808  
   3.809 @@ -896,6 +454,21 @@
   3.810  [time] 
   3.811  [time] Total runtime: 11994 ms (Non-runtime: 11027 ms [91%])
   3.812  
   3.813 +* methodhandles
   3.814 +
   3.815 +If this logger is enabled, each MethodHandle related call that uses
   3.816 +the java.lang.invoke package gets its MethodHandle intercepted and an
   3.817 +instrumentation printout of arguments and return value appended to
   3.818 +it. This shows exactly which method handles are executed and from
   3.819 +where. (Also MethodTypes and SwitchPoints).
   3.820 +
   3.821 +* classcache
   3.822 +
   3.823 +This logger shows information about reusing code classes using the
   3.824 +in-memory class cache. Nashorn will try to avoid compilation of
   3.825 +scripts by using existing classes. This can significantly improve
   3.826 +performance when repeatedly evaluating the same script.
   3.827 +
   3.828  =======================
   3.829  3. Undocumented options
   3.830  =======================

     4.1 --- a/make/build-nasgen.xml	Mon Oct 27 14:36:13 2014 -0700
     4.2 +++ b/make/build-nasgen.xml	Thu Nov 06 09:50:15 2014 -0800
     4.3 @@ -25,7 +25,7 @@
     4.4      <description>Builds and runs nasgen.</description>
     4.5      <import file="build.xml"/>
     4.6  
     4.7 -    <target name="build-nasgen" depends="compile-asm">
     4.8 +    <target name="build-nasgen" depends="prepare">
     4.9          <ant inheritAll="false" dir="${basedir}/buildtools/nasgen"
    4.10              antfile="build.xml" target="jar"/>
    4.11      </target>

     5.1 --- a/make/build.xml	Mon Oct 27 14:36:13 2014 -0700
     5.2 +++ b/make/build.xml	Thu Nov 06 09:50:15 2014 -0800
     5.3 @@ -49,8 +49,6 @@
     5.4      <condition property="git.executable" value="/usr/local/bin/git" else="git">
     5.5        <available file="/usr/local/bin/git"/>
     5.6      </condition>
     5.7 -    <!-- check if JDK already has ASM classes -->
     5.8 -    <available property="asm.available" classname="jdk.internal.org.objectweb.asm.Type"/>
     5.9      <!-- check if testng.jar is avaiable -->
    5.10      <available property="testng.available" file="${file.reference.testng.jar}"/>
    5.11      <!-- check if Jemmy ang testng.jar are avaiable -->
    5.12 @@ -78,8 +76,31 @@
    5.13        <istrue value="${jfr}"/>
    5.14      </condition>
    5.15    </target>
    5.16 +
    5.17 +  <!-- check minimum ant version required to be 1.8.4 -->
    5.18 +  <target name="check-ant-version">
    5.19 +    <property name="ant.version.required" value="1.8.4"/>
    5.20 +    <antversion property="ant.current.version" />
    5.21 +    <fail message="The current ant version, ${ant.current.version}, is too old. Please use 1.8.4 or above.">
    5.22 +        <condition>
    5.23 +            <not>
    5.24 +                <antversion atleast="${ant.version.required}"/>
    5.25 +            </not>
    5.26 +        </condition>
    5.27 +    </fail>
    5.28 +  </target>
    5.29 +
    5.30 +  <target name="check-java-version">
    5.31 +    <!-- look for a Class that is available only in jdk1.8 or above -->
    5.32 +    <!-- core/exposed API class is better than an implementation class -->
    5.33 +    <available property="jdk1.8+" classname="java.util.stream.Stream"/>
    5.34 +
    5.35 +    <!-- need jdk1.8 or above -->
    5.36 +    <fail message="Unsupported Java version: ${ant.java.version}. Please use Java version 1.8 or greater." unless="jdk1.8+">
    5.37 +    </fail>
    5.38 +  </target>
    5.39    
    5.40 -  <target name="init" depends="init-conditions, init-cc">
    5.41 +  <target name="init" depends="check-ant-version, check-java-version, init-conditions, init-cc">
    5.42      <!-- extends jvm args -->
    5.43      <property name="run.test.jvmargs" value="${run.test.jvmargs.main} ${run.test.cc.jvmargs} ${jfr.options}"/>
    5.44      <property name="run.test.jvmargs.octane" value="${run.test.jvmargs.octane.main} ${run.test.cc.jvmargs} ${jfr.options}"/>
    5.45 @@ -107,19 +128,7 @@
    5.46      <delete dir="${dist.dir}"/>
    5.47    </target>
    5.48  
    5.49 -  <!-- do it only if ASM is not available -->
    5.50 -  <target name="compile-asm" depends="prepare" unless="asm.available">
    5.51 -    <javac srcdir="${jdk.asm.src.dir}"
    5.52 -           destdir="${build.classes.dir}"
    5.53 -           excludes="**/optimizer/* **/xml/* **/attrs/*"
    5.54 -           source="${javac.source}"
    5.55 -           target="${javac.target}"
    5.56 -           debug="${javac.debug}"
    5.57 -           encoding="${javac.encoding}"
    5.58 -           includeantruntime="false"/>
    5.59 -  </target>
    5.60 -
    5.61 -  <target name="compile" depends="compile-asm" description="Compiles nashorn">
    5.62 +  <target name="compile" depends="prepare" description="Compiles nashorn">
    5.63      <javac srcdir="${src.dir}"
    5.64             destdir="${build.classes.dir}"
    5.65             classpath="${javac.classpath}"
    5.66 @@ -407,7 +416,7 @@
    5.67      <fileset id="test.nosecurity.classes" dir="${build.test.classes.dir}">
    5.68        <include name="**/framework/ScriptTest.class"/>
    5.69      </fileset>
    5.70 -    <testng outputdir="${build.nosecurity.test.results.dir}" classfilesetref="test.nosecurity.classes"
    5.71 +    <testng outputdir="${build.nosecurity.test.results.dir}/${testResultsSubDir}" classfilesetref="test.nosecurity.classes"
    5.72         verbose="${testng.verbose}" haltonfailure="true" useDefaultListeners="false" listeners="${testng.listeners}" workingDir="${basedir}">
    5.73        <jvmarg line="${ext.class.path}"/>
    5.74        <jvmarg line="${run.test.jvmargs} -Xmx${run.test.xmx} -Dbuild.dir=${build.dir}"/>
    5.75 @@ -430,7 +439,7 @@
    5.76    <target name="-test-security">
    5.77      <delete dir="${build.dir}/nashorn_code_cache"/>
    5.78      <property name="debug.test.jvmargs" value=""/>
    5.79 -    <testng outputdir="${build.test.results.dir}" classfilesetref="test.classes"
    5.80 +    <testng outputdir="${build.test.results.dir}/${testResultsSubDir}" classfilesetref="test.classes"
    5.81  	    verbose="${testng.verbose}" haltonfailure="true" useDefaultListeners="false" listeners="${testng.listeners}" workingDir="${basedir}">
    5.82        <jvmarg line="${ext.class.path}"/>
    5.83        <jvmarg line="${run.test.jvmargs} -Xmx${run.test.xmx} ${run.test.jvmsecurityargs} -Dbuild.dir=${build.dir}"/>
    5.84 @@ -456,9 +465,11 @@
    5.85      <echo message="Running test suite in OPTIMISTIC mode..."/>
    5.86      <antcall target="-test-nosecurity" inheritRefs="true">
    5.87        <param name="optimistic" value="true"/>
    5.88 +      <param name="testResultsSubDir" value="optimistic"/>
    5.89      </antcall>    
    5.90      <antcall target="-test-security" inheritRefs="true">
    5.91        <param name="optimistic" value="true"/>
    5.92 +      <param name="testResultsSubDir" value="optimistic"/>
    5.93      </antcall>
    5.94    </target>
    5.95  
    5.96 @@ -466,9 +477,11 @@
    5.97      <echo message="Running test suite in PESSIMISTIC mode..."/>
    5.98      <antcall target="-test-nosecurity" inheritRefs="true">
    5.99        <param name="optimistic" value="false"/>
   5.100 +      <param name="testResultsSubDir" value="pessimistic"/>
   5.101      </antcall>    
   5.102      <antcall target="-test-security" inheritRefs="true">
   5.103        <param name="optimistic" value="false"/>
   5.104 +      <param name="testResultsSubDir" value="pessimistic"/>
   5.105      </antcall>
   5.106    </target>
   5.107  

     6.1 --- a/src/jdk/nashorn/api/scripting/NashornScriptEngine.java	Mon Oct 27 14:36:13 2014 -0700
     6.2 +++ b/src/jdk/nashorn/api/scripting/NashornScriptEngine.java	Thu Nov 06 09:50:15 2014 -0800
     6.3 @@ -229,6 +229,8 @@
     6.4      }
     6.5  
     6.6      private <T> T getInterfaceInner(final Object thiz, final Class<T> clazz) {
     6.7 +        assert !(thiz instanceof ScriptObject) : "raw ScriptObject not expected here";
     6.8 +
     6.9          if (clazz == null || !clazz.isInterface()) {
    6.10              throw new IllegalArgumentException(getMessage("interface.class.expected"));
    6.11          }
    6.12 @@ -254,17 +256,6 @@
    6.13              if (! isOfContext(realGlobal, nashornContext)) {
    6.14                  throw new IllegalArgumentException(getMessage("script.object.from.another.engine"));
    6.15              }
    6.16 -        } else if (thiz instanceof ScriptObject) {
    6.17 -            // called from script code.
    6.18 -            realSelf = (ScriptObject)thiz;
    6.19 -            realGlobal = Context.getGlobal();
    6.20 -            if (realGlobal == null) {
    6.21 -                throw new IllegalArgumentException(getMessage("no.current.nashorn.global"));
    6.22 -            }
    6.23 -
    6.24 -            if (! isOfContext(realGlobal, nashornContext)) {
    6.25 -                throw new IllegalArgumentException(getMessage("script.object.from.another.engine"));
    6.26 -            }
    6.27          }
    6.28  
    6.29          if (realSelf == null) {
    6.30 @@ -368,6 +359,7 @@
    6.31  
    6.32      private Object invokeImpl(final Object selfObject, final String name, final Object... args) throws ScriptException, NoSuchMethodException {
    6.33          name.getClass(); // null check
    6.34 +        assert !(selfObject instanceof ScriptObject) : "raw ScriptObject not expected here";
    6.35  
    6.36          Global invokeGlobal = null;
    6.37          ScriptObjectMirror selfMirror = null;
    6.38 @@ -377,20 +369,6 @@
    6.39                  throw new IllegalArgumentException(getMessage("script.object.from.another.engine"));
    6.40              }
    6.41              invokeGlobal = selfMirror.getHomeGlobal();
    6.42 -        } else if (selfObject instanceof ScriptObject) {
    6.43 -            // invokeMethod called from script code - in which case we may get 'naked' ScriptObject
    6.44 -            // Wrap it with oldGlobal to make a ScriptObjectMirror for the same.
    6.45 -            final Global oldGlobal = Context.getGlobal();
    6.46 -            invokeGlobal = oldGlobal;
    6.47 -            if (oldGlobal == null) {
    6.48 -                throw new IllegalArgumentException(getMessage("no.current.nashorn.global"));
    6.49 -            }
    6.50 -
    6.51 -            if (! isOfContext(oldGlobal, nashornContext)) {
    6.52 -                throw new IllegalArgumentException(getMessage("script.object.from.another.engine"));
    6.53 -            }
    6.54 -
    6.55 -            selfMirror = (ScriptObjectMirror)ScriptObjectMirror.wrap(selfObject, oldGlobal);
    6.56          } else if (selfObject == null) {
    6.57              // selfObject is null => global function call
    6.58              final Global ctxtGlobal = getNashornGlobalFrom(context);

     7.1 --- a/src/jdk/nashorn/api/scripting/ScriptUtils.java	Mon Oct 27 14:36:13 2014 -0700
     7.2 +++ b/src/jdk/nashorn/api/scripting/ScriptUtils.java	Thu Nov 06 09:50:15 2014 -0800
     7.3 @@ -75,11 +75,8 @@
     7.4       * @param sync the object to synchronize on
     7.5       * @return a synchronizing wrapper function
     7.6       */
     7.7 -    public static Object makeSynchronizedFunction(final Object func, final Object sync) {
     7.8 -        if (func instanceof ScriptFunction) {
     7.9 -           return ((ScriptFunction)func).makeSynchronizedFunction(sync);
    7.10 -        }
    7.11 -        throw typeError("not.a.function", ScriptRuntime.safeToString(func));
    7.12 +    public static Object makeSynchronizedFunction(final ScriptFunction func, final Object sync) {
    7.13 +        return func.makeSynchronizedFunction(unwrap(sync));
    7.14      }
    7.15  
    7.16      /**
    7.17 @@ -88,12 +85,8 @@
    7.18       * @param obj object to be wrapped
    7.19       * @return wrapped object
    7.20       */
    7.21 -    public static Object wrap(final Object obj) {
    7.22 -        if (obj instanceof ScriptObject) {
    7.23 -            return ScriptObjectMirror.wrap(obj, Context.getGlobal());
    7.24 -        }
    7.25 -
    7.26 -        return obj;
    7.27 +    public static ScriptObjectMirror wrap(final ScriptObject obj) {
    7.28 +        return (ScriptObjectMirror) ScriptObjectMirror.wrap(obj, Context.getGlobal());
    7.29      }
    7.30  
    7.31      /**
    7.32 @@ -160,14 +153,15 @@
    7.33          }
    7.34  
    7.35          final LinkerServices linker = Bootstrap.getLinkerServices();
    7.36 -        final MethodHandle converter = linker.getTypeConverter(obj.getClass(),  clazz);
    7.37 +        final Object objToConvert = unwrap(obj);
    7.38 +        final MethodHandle converter = linker.getTypeConverter(objToConvert.getClass(),  clazz);
    7.39          if (converter == null) {
    7.40              // no supported conversion!
    7.41              throw new UnsupportedOperationException("conversion not supported");
    7.42          }
    7.43  
    7.44          try {
    7.45 -            return converter.invoke(obj);
    7.46 +            return converter.invoke(objToConvert);
    7.47          } catch (final RuntimeException | Error e) {
    7.48              throw e;
    7.49          } catch (final Throwable t) {

     8.1 --- a/src/jdk/nashorn/internal/codegen/ApplySpecialization.java	Mon Oct 27 14:36:13 2014 -0700
     8.2 +++ b/src/jdk/nashorn/internal/codegen/ApplySpecialization.java	Thu Nov 06 09:50:15 2014 -0800
     8.3 @@ -27,6 +27,7 @@
     8.4  
     8.5  import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS_VAR;
     8.6  import static jdk.nashorn.internal.codegen.CompilerConstants.EXPLODED_ARGUMENT_PREFIX;
     8.7 +
     8.8  import java.lang.invoke.MethodType;
     8.9  import java.util.ArrayDeque;
    8.10  import java.util.ArrayList;
    8.11 @@ -38,6 +39,7 @@
    8.12  import jdk.nashorn.internal.ir.CallNode;
    8.13  import jdk.nashorn.internal.ir.Expression;
    8.14  import jdk.nashorn.internal.ir.FunctionNode;
    8.15 +import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
    8.16  import jdk.nashorn.internal.ir.IdentNode;
    8.17  import jdk.nashorn.internal.ir.LexicalContext;
    8.18  import jdk.nashorn.internal.ir.Node;
    8.19 @@ -321,7 +323,7 @@
    8.20  
    8.21          explodedArguments.pop();
    8.22  
    8.23 -        return newFunctionNode;
    8.24 +        return newFunctionNode.setState(lc, CompilationState.BUILTINS_TRANSFORMED);
    8.25      }
    8.26  
    8.27      private static boolean isApply(final CallNode callNode) {

     9.1 --- a/src/jdk/nashorn/internal/codegen/AssignSymbols.java	Mon Oct 27 14:36:13 2014 -0700
     9.2 +++ b/src/jdk/nashorn/internal/codegen/AssignSymbols.java	Thu Nov 06 09:50:15 2014 -0800
     9.3 @@ -76,7 +76,6 @@
     9.4  import jdk.nashorn.internal.ir.Node;
     9.5  import jdk.nashorn.internal.ir.RuntimeNode;
     9.6  import jdk.nashorn.internal.ir.RuntimeNode.Request;
     9.7 -import jdk.nashorn.internal.ir.SplitNode;
     9.8  import jdk.nashorn.internal.ir.Statement;
     9.9  import jdk.nashorn.internal.ir.SwitchNode;
    9.10  import jdk.nashorn.internal.ir.Symbol;
    9.11 @@ -135,9 +134,6 @@
    9.12          if (!(functionNode.hasScopeBlock() || functionNode.needsParentScope())) {
    9.13              functionNode.compilerConstant(SCOPE).setNeedsSlot(false);
    9.14          }
    9.15 -        if (!functionNode.usesReturnSymbol()) {
    9.16 -            functionNode.compilerConstant(RETURN).setNeedsSlot(false);
    9.17 -        }
    9.18          // Named function expressions that end up not referencing themselves won't need a local slot for the self symbol.
    9.19          if(!functionNode.isDeclared() && !functionNode.usesSelfSymbol() && !functionNode.isAnonymous()) {
    9.20              final Symbol selfSymbol = functionNode.getBody().getExistingSymbol(functionNode.getIdent().getName());
    9.21 @@ -511,16 +507,6 @@
    9.22  
    9.23          thisProperties.push(new HashSet<String>());
    9.24  
    9.25 -        if (functionNode.isDeclared()) {
    9.26 -            // Can't use lc.getCurrentBlock() as we can have an outermost function in our lexical context that
    9.27 -            // is not a program - it is a function being compiled on-demand.
    9.28 -            final Iterator<Block> blocks = lc.getBlocks();
    9.29 -            if (blocks.hasNext()) {
    9.30 -                final IdentNode ident = functionNode.getIdent();
    9.31 -                defineSymbol(blocks.next(), ident.getName(), ident, IS_VAR | (functionNode.isAnonymous()? IS_INTERNAL : 0));
    9.32 -            }
    9.33 -        }
    9.34 -
    9.35          // Every function has a body, even the ones skipped on reparse (they have an empty one). We're
    9.36          // asserting this as even for those, enterBlock() must be invoked to correctly process symbols that
    9.37          // are used in them.
    9.38 @@ -532,14 +518,34 @@
    9.39      @Override
    9.40      public boolean enterVarNode(final VarNode varNode) {
    9.41          start(varNode);
    9.42 +        // Normally, a symbol assigned in a var statement is not live for its RHS. Since we also represent function
    9.43 +        // declarations as VarNodes, they are exception to the rule, as they need to have the symbol visible to the
    9.44 +        // body of the declared function for self-reference.
    9.45 +        if (varNode.isFunctionDeclaration()) {
    9.46 +            defineVarIdent(varNode);
    9.47 +        }
    9.48          return true;
    9.49      }
    9.50  
    9.51      @Override
    9.52      public Node leaveVarNode(final VarNode varNode) {
    9.53 +        if (!varNode.isFunctionDeclaration()) {
    9.54 +            defineVarIdent(varNode);
    9.55 +        }
    9.56 +        return super.leaveVarNode(varNode);
    9.57 +    }
    9.58 +
    9.59 +    private void defineVarIdent(final VarNode varNode) {
    9.60          final IdentNode ident = varNode.getName();
    9.61 -        defineSymbol(lc.getCurrentBlock(), ident.getName(), ident, varNode.getSymbolFlags() | (lc.getCurrentFunction().isProgram() ? IS_SCOPE : 0));
    9.62 -        return super.leaveVarNode(varNode);
    9.63 +        final int flags;
    9.64 +        if (varNode.isAnonymousFunctionDeclaration()) {
    9.65 +            flags = IS_INTERNAL;
    9.66 +        } else if (lc.getCurrentFunction().isProgram()) {
    9.67 +            flags = IS_SCOPE;
    9.68 +        } else {
    9.69 +            flags = 0;
    9.70 +        }
    9.71 +        defineSymbol(lc.getCurrentBlock(), ident.getName(), ident, varNode.getSymbolFlags() | flags);
    9.72      }
    9.73  
    9.74      private Symbol exceptionSymbol() {
    9.75 @@ -1004,7 +1010,7 @@
    9.76          boolean previousWasBlock = false;
    9.77          for (final Iterator<LexicalContextNode> it = lc.getAllNodes(); it.hasNext();) {
    9.78              final LexicalContextNode node = it.next();
    9.79 -            if (node instanceof FunctionNode || node instanceof SplitNode || isSplitArray(node)) {
    9.80 +            if (node instanceof FunctionNode || isSplitArray(node)) {
    9.81                  // We reached the function boundary or a splitting boundary without seeing a definition for the symbol.
    9.82                  // It needs to be in scope.
    9.83                  return true;

    10.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    10.2 +++ b/src/jdk/nashorn/internal/codegen/AstSerializer.java	Thu Nov 06 09:50:15 2014 -0800
    10.3 @@ -0,0 +1,71 @@
    10.4 +/*
    10.5 + * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
    10.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    10.7 + *
    10.8 + * This code is free software; you can redistribute it and/or modify it
    10.9 + * under the terms of the GNU General Public License version 2 only, as
   10.10 + * published by the Free Software Foundation.  Oracle designates this
   10.11 + * particular file as subject to the "Classpath" exception as provided
   10.12 + * by Oracle in the LICENSE file that accompanied this code.
   10.13 + *
   10.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   10.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   10.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   10.17 + * version 2 for more details (a copy is included in the LICENSE file that
   10.18 + * accompanied this code).
   10.19 + *
   10.20 + * You should have received a copy of the GNU General Public License version
   10.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   10.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   10.23 + *
   10.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   10.25 + * or visit www.oracle.com if you need additional information or have any
   10.26 + * questions.
   10.27 + */
   10.28 +package jdk.nashorn.internal.codegen;
   10.29 +
   10.30 +import java.io.ByteArrayOutputStream;
   10.31 +import java.io.IOException;
   10.32 +import java.io.ObjectOutputStream;
   10.33 +import java.util.Collections;
   10.34 +import java.util.zip.Deflater;
   10.35 +import java.util.zip.DeflaterOutputStream;
   10.36 +import jdk.nashorn.internal.ir.Block;
   10.37 +import jdk.nashorn.internal.ir.FunctionNode;
   10.38 +import jdk.nashorn.internal.ir.LexicalContext;
   10.39 +import jdk.nashorn.internal.ir.Node;
   10.40 +import jdk.nashorn.internal.ir.Statement;
   10.41 +import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   10.42 +import jdk.nashorn.internal.runtime.options.Options;
   10.43 +
   10.44 +/**
   10.45 + * This static utility class performs serialization of FunctionNode ASTs to a byte array.
   10.46 + * The format is a standard Java serialization stream, deflated.
   10.47 + */
   10.48 +final class AstSerializer {
   10.49 +    // Experimentally, we concluded that compression level 4 gives a good tradeoff between serialization speed
   10.50 +    // and size.
   10.51 +    private static final int COMPRESSION_LEVEL = Options.getIntProperty("nashorn.serialize.compression", 4);
   10.52 +    static byte[] serialize(final FunctionNode fn) {
   10.53 +        final ByteArrayOutputStream out = new ByteArrayOutputStream();
   10.54 +        try (final ObjectOutputStream oout = new ObjectOutputStream(new DeflaterOutputStream(out,
   10.55 +                new Deflater(COMPRESSION_LEVEL)))) {
   10.56 +            oout.writeObject(removeInnerFunctionBodies(fn));
   10.57 +        } catch (final IOException e) {
   10.58 +            throw new AssertionError("Unexpected exception serializing function", e);
   10.59 +        }
   10.60 +        return out.toByteArray();
   10.61 +    }
   10.62 +
   10.63 +    private static FunctionNode removeInnerFunctionBodies(final FunctionNode fn) {
   10.64 +        return (FunctionNode)fn.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   10.65 +            @Override
   10.66 +            public Node leaveBlock(final Block block) {
   10.67 +                if (lc.isFunctionBody() && lc.getFunction(block) != lc.getOutermostFunction()) {
   10.68 +                    return block.setStatements(lc, Collections.<Statement>emptyList());
   10.69 +                }
   10.70 +                return super.leaveBlock(block);
   10.71 +            }
   10.72 +        });
   10.73 +    }
   10.74 +}

    11.1 --- a/src/jdk/nashorn/internal/codegen/ClassEmitter.java	Mon Oct 27 14:36:13 2014 -0700
    11.2 +++ b/src/jdk/nashorn/internal/codegen/ClassEmitter.java	Thu Nov 06 09:50:15 2014 -0800
    11.3 @@ -51,6 +51,7 @@
    11.4  import static jdk.nashorn.internal.codegen.CompilerConstants.methodDescriptor;
    11.5  import static jdk.nashorn.internal.codegen.CompilerConstants.typeDescriptor;
    11.6  import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCallNoLookup;
    11.7 +
    11.8  import java.io.ByteArrayOutputStream;
    11.9  import java.io.PrintWriter;
   11.10  import java.security.AccessController;
   11.11 @@ -64,7 +65,6 @@
   11.12  import jdk.internal.org.objectweb.asm.util.TraceClassVisitor;
   11.13  import jdk.nashorn.internal.codegen.types.Type;
   11.14  import jdk.nashorn.internal.ir.FunctionNode;
   11.15 -import jdk.nashorn.internal.ir.SplitNode;
   11.16  import jdk.nashorn.internal.ir.debug.NashornClassReader;
   11.17  import jdk.nashorn.internal.ir.debug.NashornTextifier;
   11.18  import jdk.nashorn.internal.runtime.Context;
   11.19 @@ -476,12 +476,6 @@
   11.20          methodsStarted.remove(method);
   11.21      }
   11.22  
   11.23 -    SplitMethodEmitter method(final SplitNode splitNode, final String methodName, final Class<?> rtype, final Class<?>... ptypes) {
   11.24 -        methodCount++;
   11.25 -        methodNames.add(methodName);
   11.26 -        return new SplitMethodEmitter(this, methodVisitor(EnumSet.of(Flag.PUBLIC, Flag.STATIC), methodName, rtype, ptypes), splitNode);
   11.27 -    }
   11.28 -
   11.29      /**
   11.30       * Add a new method to the class - defaults to public method
   11.31       *

    12.1 --- a/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Mon Oct 27 14:36:13 2014 -0700
    12.2 +++ b/src/jdk/nashorn/internal/codegen/CodeGenerator.java	Thu Nov 06 09:50:15 2014 -0800
    12.3 @@ -34,9 +34,7 @@
    12.4  import static jdk.nashorn.internal.codegen.CompilerConstants.GET_STRING;
    12.5  import static jdk.nashorn.internal.codegen.CompilerConstants.QUICK_PREFIX;
    12.6  import static jdk.nashorn.internal.codegen.CompilerConstants.REGEX_PREFIX;
    12.7 -import static jdk.nashorn.internal.codegen.CompilerConstants.RETURN;
    12.8  import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;
    12.9 -import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_ARRAY_ARG;
   12.10  import static jdk.nashorn.internal.codegen.CompilerConstants.SPLIT_PREFIX;
   12.11  import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
   12.12  import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
   12.13 @@ -99,10 +97,10 @@
   12.14  import jdk.nashorn.internal.ir.ForNode;
   12.15  import jdk.nashorn.internal.ir.FunctionNode;
   12.16  import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
   12.17 +import jdk.nashorn.internal.ir.GetSplitState;
   12.18  import jdk.nashorn.internal.ir.IdentNode;
   12.19  import jdk.nashorn.internal.ir.IfNode;
   12.20  import jdk.nashorn.internal.ir.IndexNode;
   12.21 -import jdk.nashorn.internal.ir.JoinPredecessor;
   12.22  import jdk.nashorn.internal.ir.JoinPredecessorExpression;
   12.23  import jdk.nashorn.internal.ir.JumpStatement;
   12.24  import jdk.nashorn.internal.ir.LabelNode;
   12.25 @@ -121,7 +119,8 @@
   12.26  import jdk.nashorn.internal.ir.ReturnNode;
   12.27  import jdk.nashorn.internal.ir.RuntimeNode;
   12.28  import jdk.nashorn.internal.ir.RuntimeNode.Request;
   12.29 -import jdk.nashorn.internal.ir.SplitNode;
   12.30 +import jdk.nashorn.internal.ir.SetSplitState;
   12.31 +import jdk.nashorn.internal.ir.SplitReturn;
   12.32  import jdk.nashorn.internal.ir.Statement;
   12.33  import jdk.nashorn.internal.ir.SwitchNode;
   12.34  import jdk.nashorn.internal.ir.Symbol;
   12.35 @@ -209,6 +208,8 @@
   12.36      private static final Type ITERATOR_TYPE = Type.typeFor(ITERATOR_CLASS);
   12.37      private static final Type EXCEPTION_TYPE = Type.typeFor(CompilerConstants.EXCEPTION_PREFIX.type());
   12.38  
   12.39 +    private static final Integer INT_ZERO = Integer.valueOf(0);
   12.40 +
   12.41      /** Constant data & installation. The only reason the compiler keeps this is because it is assigned
   12.42       *  by reflection in class installation */
   12.43      private final Compiler compiler;
   12.44 @@ -493,8 +494,7 @@
   12.45          //walk up the chain from starting block and when we bump into the current function boundary, add the external
   12.46          //information.
   12.47          final FunctionNode fn   = lc.getCurrentFunction();
   12.48 -        final int          fnId = fn.getId();
   12.49 -        final int externalDepth = compiler.getScriptFunctionData(fnId).getExternalSymbolDepth(symbol.getName());
   12.50 +        final int externalDepth = compiler.getScriptFunctionData(fn.getId()).getExternalSymbolDepth(symbol.getName());
   12.51  
   12.52          //count the number of scopes from this place to the start of the function
   12.53  
   12.54 @@ -554,10 +554,10 @@
   12.55      }
   12.56  
   12.57      MethodEmitter loadBinaryOperands(final BinaryNode binaryNode) {
   12.58 -        return loadBinaryOperands(binaryNode.lhs(), binaryNode.rhs(), TypeBounds.UNBOUNDED.notWiderThan(binaryNode.getWidestOperandType()), false);
   12.59 +        return loadBinaryOperands(binaryNode.lhs(), binaryNode.rhs(), TypeBounds.UNBOUNDED.notWiderThan(binaryNode.getWidestOperandType()), false, false);
   12.60      }
   12.61  
   12.62 -    private MethodEmitter loadBinaryOperands(final Expression lhs, final Expression rhs, final TypeBounds explicitOperandBounds, final boolean baseAlreadyOnStack) {
   12.63 +    private MethodEmitter loadBinaryOperands(final Expression lhs, final Expression rhs, final TypeBounds explicitOperandBounds, final boolean baseAlreadyOnStack, final boolean forceConversionSeparation) {
   12.64          // ECMAScript 5.1 specification (sections 11.5-11.11 and 11.13) prescribes that when evaluating a binary
   12.65          // expression "LEFT op RIGHT", the order of operations must be: LOAD LEFT, LOAD RIGHT, CONVERT LEFT, CONVERT
   12.66          // RIGHT, EXECUTE OP. Unfortunately, doing it in this order defeats potential optimizations that arise when we
   12.67 @@ -574,15 +574,34 @@
   12.68          final Type narrowestOperandType = Type.narrowest(Type.widest(lhs.getType(), rhs.getType()), explicitOperandBounds.widest);
   12.69          final TypeBounds operandBounds = explicitOperandBounds.notNarrowerThan(narrowestOperandType);
   12.70          if (noToPrimitiveConversion(lhs.getType(), explicitOperandBounds.widest) || rhs.isLocal()) {
   12.71 -            // Can reorder. Combine load and convert into single operations.
   12.72 -            loadExpression(lhs, operandBounds, baseAlreadyOnStack);
   12.73 -            loadExpression(rhs, operandBounds, false);
   12.74 +            // Can reorder. We might still need to separate conversion, but at least we can do it with reordering
   12.75 +            if (forceConversionSeparation) {
   12.76 +                // Can reorder, but can't move conversion into the operand as the operation depends on operands
   12.77 +                // exact types for its overflow guarantees. E.g. with {L}{%I}expr1 {L}* {L}{%I}expr2 we are not allowed
   12.78 +                // to merge {L}{%I} into {%L}, as that can cause subsequent overflows; test for JDK-8058610 contains
   12.79 +                // concrete cases where this could happen.
   12.80 +                final TypeBounds safeConvertBounds = TypeBounds.UNBOUNDED.notNarrowerThan(narrowestOperandType);
   12.81 +                loadExpression(lhs, safeConvertBounds, baseAlreadyOnStack);
   12.82 +                method.convert(operandBounds.within(method.peekType()));
   12.83 +                loadExpression(rhs, safeConvertBounds, false);
   12.84 +                method.convert(operandBounds.within(method.peekType()));
   12.85 +            } else {
   12.86 +                // Can reorder and move conversion into the operand. Combine load and convert into single operations.
   12.87 +                loadExpression(lhs, operandBounds, baseAlreadyOnStack);
   12.88 +                loadExpression(rhs, operandBounds, false);
   12.89 +            }
   12.90          } else {
   12.91              // Can't reorder. Load and convert separately.
   12.92              final TypeBounds safeConvertBounds = TypeBounds.UNBOUNDED.notNarrowerThan(narrowestOperandType);
   12.93              loadExpression(lhs, safeConvertBounds, baseAlreadyOnStack);
   12.94 +            final Type lhsType = method.peekType();
   12.95              loadExpression(rhs, safeConvertBounds, false);
   12.96 -            method.swap().convert(operandBounds.within(method.peekType())).swap().convert(operandBounds.within(method.peekType()));
   12.97 +            final Type convertedLhsType = operandBounds.within(method.peekType());
   12.98 +            if (convertedLhsType != lhsType) {
   12.99 +                // Do it conditionally, so that if conversion is a no-op we don't introduce a SWAP, SWAP.
  12.100 +                method.swap().convert(convertedLhsType).swap();
  12.101 +            }
  12.102 +            method.convert(operandBounds.within(method.peekType()));
  12.103          }
  12.104          assert Type.generic(method.peekType()) == operandBounds.narrowest;
  12.105          assert Type.generic(method.peekType(1)) == operandBounds.narrowest;
  12.106 @@ -633,19 +652,11 @@
  12.107          }
  12.108  
  12.109          TypeBounds booleanToInt() {
  12.110 -            return maybeNew(booleanToInt(narrowest), booleanToInt(widest));
  12.111 +            return maybeNew(CodeGenerator.booleanToInt(narrowest), CodeGenerator.booleanToInt(widest));
  12.112          }
  12.113  
  12.114          TypeBounds objectToNumber() {
  12.115 -            return maybeNew(objectToNumber(narrowest), objectToNumber(widest));
  12.116 -        }
  12.117 -
  12.118 -        private static Type booleanToInt(final Type t) {
  12.119 -            return t == Type.BOOLEAN ? Type.INT : t;
  12.120 -        }
  12.121 -
  12.122 -        private static Type objectToNumber(final Type t) {
  12.123 -            return t.isObject() ? Type.NUMBER : t;
  12.124 +            return maybeNew(CodeGenerator.objectToNumber(narrowest), CodeGenerator.objectToNumber(widest));
  12.125          }
  12.126  
  12.127          Type within(final Type type) {
  12.128 @@ -664,6 +675,14 @@
  12.129          }
  12.130      }
  12.131  
  12.132 +    private static Type booleanToInt(final Type t) {
  12.133 +        return t == Type.BOOLEAN ? Type.INT : t;
  12.134 +    }
  12.135 +
  12.136 +    private static Type objectToNumber(final Type t) {
  12.137 +        return t.isObject() ? Type.NUMBER : t;
  12.138 +    }
  12.139 +
  12.140      MethodEmitter loadExpressionAsType(final Expression expr, final Type type) {
  12.141          if(type == Type.BOOLEAN) {
  12.142              return loadExpressionAsBoolean(expr);
  12.143 @@ -1048,6 +1067,13 @@
  12.144              }
  12.145  
  12.146              @Override
  12.147 +            public boolean enterGetSplitState(final GetSplitState getSplitState) {
  12.148 +                method.loadScope();
  12.149 +                method.invoke(Scope.GET_SPLIT_STATE);
  12.150 +                return false;
  12.151 +            }
  12.152 +
  12.153 +            @Override
  12.154              public boolean enterDefault(final Node otherNode) {
  12.155                  // Must have handled all expressions that can legally be encountered.
  12.156                  throw new AssertionError(otherNode.getClass().getName());
  12.157 @@ -1219,7 +1245,7 @@
  12.158          popScopesUntil(target);
  12.159          final Label targetLabel = jump.getTargetLabel(target);
  12.160          targetLabel.markAsBreakTarget();
  12.161 -        method.splitAwareGoto(lc, targetLabel, target);
  12.162 +        method._goto(targetLabel);
  12.163  
  12.164          return false;
  12.165      }
  12.166 @@ -2029,10 +2055,10 @@
  12.167      }
  12.168  
  12.169      private void lineNumber(final int lineNumber) {
  12.170 -        if (lineNumber != lastLineNumber) {
  12.171 +        if (lineNumber != lastLineNumber && lineNumber != Node.NO_LINE_NUMBER) {
  12.172              method.lineNumber(lineNumber);
  12.173 -        }
  12.174 -        lastLineNumber = lineNumber;
  12.175 +            lastLineNumber = lineNumber;
  12.176 +        }
  12.177      }
  12.178  
  12.179      int getLastLineNumber() {
  12.180 @@ -2079,13 +2105,14 @@
  12.181                  method.begin();
  12.182  
  12.183                  defineCommonSplitMethodParameters();
  12.184 -                defineSplitMethodParameter(3, arrayType);
  12.185 -
  12.186 -                fixScopeSlot(currentFunction);
  12.187 +                defineSplitMethodParameter(CompilerConstants.SPLIT_ARRAY_ARG.slot(), arrayType);
  12.188 +
  12.189 +                // NOTE: when this is no longer needed, SplitIntoFunctions will no longer have to add IS_SPLIT
  12.190 +                // to synthetic functions, and FunctionNode.needsCallee() will no longer need to test for isSplit().
  12.191 +                final int arraySlot = fixScopeSlot(currentFunction, 3);
  12.192  
  12.193                  lc.enterSplitNode();
  12.194  
  12.195 -                final int arraySlot = SPLIT_ARRAY_ARG.slot();
  12.196                  for (int i = arrayUnit.getLo(); i < arrayUnit.getHi(); i++) {
  12.197                      method.load(arrayType, arraySlot);
  12.198                      storeElement(nodes, elementType, postsets[i]);
  12.199 @@ -2700,73 +2727,6 @@
  12.200          method.convert(newRuntimeNode.getType());
  12.201      }
  12.202  
  12.203 -    @Override
  12.204 -    public boolean enterSplitNode(final SplitNode splitNode) {
  12.205 -        if(!method.isReachable()) {
  12.206 -            return false;
  12.207 -        }
  12.208 -
  12.209 -        final CompileUnit splitCompileUnit = splitNode.getCompileUnit();
  12.210 -
  12.211 -        final FunctionNode fn   = lc.getCurrentFunction();
  12.212 -        final String className  = splitCompileUnit.getUnitClassName();
  12.213 -        final String name       = splitNode.getName();
  12.214 -
  12.215 -        final Type returnType = fn.getReturnType();
  12.216 -
  12.217 -        final Class<?>   rtype          = fn.getReturnType().getTypeClass();
  12.218 -        final boolean    needsArguments = fn.needsArguments();
  12.219 -        final Class<?>[] ptypes         = needsArguments ?
  12.220 -                new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class, ScriptObject.class} :
  12.221 -                new Class<?>[] {ScriptFunction.class, Object.class, ScriptObject.class};
  12.222 -
  12.223 -        final MethodEmitter caller = method;
  12.224 -        unit = lc.pushCompileUnit(splitCompileUnit);
  12.225 -
  12.226 -        final Call splitCall = staticCallNoLookup(
  12.227 -            className,
  12.228 -            name,
  12.229 -            methodDescriptor(rtype, ptypes));
  12.230 -
  12.231 -        final MethodEmitter splitEmitter =
  12.232 -                splitCompileUnit.getClassEmitter().method(
  12.233 -                        splitNode,
  12.234 -                        name,
  12.235 -                        rtype,
  12.236 -                        ptypes);
  12.237 -
  12.238 -        pushMethodEmitter(splitEmitter);
  12.239 -        method.setFunctionNode(fn);
  12.240 -
  12.241 -        assert fn.needsCallee() : "split function should require callee";
  12.242 -        caller.loadCompilerConstant(CALLEE);
  12.243 -        caller.loadCompilerConstant(THIS);
  12.244 -        caller.loadCompilerConstant(SCOPE);
  12.245 -        if (needsArguments) {
  12.246 -            caller.loadCompilerConstant(ARGUMENTS);
  12.247 -        }
  12.248 -        caller.invoke(splitCall);
  12.249 -        caller.storeCompilerConstant(RETURN, returnType);
  12.250 -
  12.251 -        method.begin();
  12.252 -
  12.253 -        defineCommonSplitMethodParameters();
  12.254 -        if(needsArguments) {
  12.255 -            defineSplitMethodParameter(3, ARGUMENTS);
  12.256 -        }
  12.257 -
  12.258 -        // Copy scope to its target slot as first thing because the original slot could be used by return symbol.
  12.259 -        fixScopeSlot(fn);
  12.260 -
  12.261 -        final int returnSlot = fn.compilerConstant(RETURN).getSlot(returnType);
  12.262 -        method.defineBlockLocalVariable(returnSlot, returnSlot + returnType.getSlots());
  12.263 -        method.loadUndefined(returnType);
  12.264 -        method.storeCompilerConstant(RETURN, returnType);
  12.265 -
  12.266 -        lc.enterSplitNode();
  12.267 -        return true;
  12.268 -    }
  12.269 -
  12.270      private void defineCommonSplitMethodParameters() {
  12.271          defineSplitMethodParameter(0, CALLEE);
  12.272          defineSplitMethodParameter(1, THIS);
  12.273 @@ -2782,114 +2742,40 @@
  12.274          method.onLocalStore(type, slot);
  12.275      }
  12.276  
  12.277 -    private void fixScopeSlot(final FunctionNode functionNode) {
  12.278 +    private int fixScopeSlot(final FunctionNode functionNode, final int extraSlot) {
  12.279          // TODO hack to move the scope to the expected slot (needed because split methods reuse the same slots as the root method)
  12.280          final int actualScopeSlot = functionNode.compilerConstant(SCOPE).getSlot(SCOPE_TYPE);
  12.281          final int defaultScopeSlot = SCOPE.slot();
  12.282 +        int newExtraSlot = extraSlot;
  12.283          if (actualScopeSlot != defaultScopeSlot) {
  12.284 -            method.defineBlockLocalVariable(actualScopeSlot, actualScopeSlot + 1);
  12.285 +            if (actualScopeSlot == extraSlot) {
  12.286 +                newExtraSlot = extraSlot + 1;
  12.287 +                method.defineBlockLocalVariable(newExtraSlot, newExtraSlot + 1);
  12.288 +                method.load(Type.OBJECT, extraSlot);
  12.289 +                method.storeHidden(Type.OBJECT, newExtraSlot);
  12.290 +            } else {
  12.291 +                method.defineBlockLocalVariable(actualScopeSlot, actualScopeSlot + 1);
  12.292 +            }
  12.293              method.load(SCOPE_TYPE, defaultScopeSlot);
  12.294              method.storeCompilerConstant(SCOPE);
  12.295          }
  12.296 +        return newExtraSlot;
  12.297      }
  12.298  
  12.299      @Override
  12.300 -    public Node leaveSplitNode(final SplitNode splitNode) {
  12.301 -        assert method instanceof SplitMethodEmitter;
  12.302 -        lc.exitSplitNode();
  12.303 -        final boolean hasReturn = method.hasReturn();
  12.304 -        final SplitMethodEmitter splitMethod = ((SplitMethodEmitter)method);
  12.305 -        final List<Label> targets = splitMethod.getExternalTargets();
  12.306 -        final boolean hasControlFlow = hasReturn || !targets.isEmpty();
  12.307 -        final List<BreakableNode> targetNodes  = splitMethod.getExternalTargetNodes();
  12.308 -        final Type returnType = lc.getCurrentFunction().getReturnType();
  12.309 -
  12.310 -        try {
  12.311 -            // Wrap up this method.
  12.312 -
  12.313 -            if(method.isReachable()) {
  12.314 -                if (hasControlFlow) {
  12.315 -                    method.setSplitState(-1);
  12.316 -                }
  12.317 -                method.loadCompilerConstant(RETURN, returnType);
  12.318 -                method._return(returnType);
  12.319 -            }
  12.320 -            method.end();
  12.321 -
  12.322 -            lc.releaseSlots();
  12.323 -
  12.324 -            unit   = lc.popCompileUnit(splitNode.getCompileUnit());
  12.325 -            popMethodEmitter();
  12.326 -
  12.327 -        } catch (final Throwable t) {
  12.328 -            Context.printStackTrace(t);
  12.329 -            final VerifyError e = new VerifyError("Code generation bug in \"" + splitNode.getName() + "\": likely stack misaligned: " + t + " " + getCurrentSource().getName());
  12.330 -            e.initCause(t);
  12.331 -            throw e;
  12.332 -        }
  12.333 -
  12.334 -        //no external jump targets or return in switch node
  12.335 -        if (!hasControlFlow) {
  12.336 -            return splitNode;
  12.337 -        }
  12.338 -
  12.339 -        // Handle return from split method if there was one.
  12.340 -        final MethodEmitter caller = method;
  12.341 -        final int     targetCount = targets.size();
  12.342 -
  12.343 -        caller.loadScope();
  12.344 -        caller.invoke(Scope.GET_SPLIT_STATE);
  12.345 -
  12.346 -        final Label breakLabel = new Label("no_split_state");
  12.347 -        // Split state is -1 for no split state, 0 for return, 1..n+1 for break/continue
  12.348 -
  12.349 -        //the common case is that we don't need a switch
  12.350 -        if (targetCount == 0) {
  12.351 -            assert hasReturn;
  12.352 -            caller.ifne(breakLabel);
  12.353 -            //has to be zero
  12.354 -            caller.label(new Label("split_return"));
  12.355 -            caller.loadCompilerConstant(RETURN, returnType);
  12.356 -            caller._return(returnType);
  12.357 -            caller.label(breakLabel);
  12.358 -        } else {
  12.359 -            assert !targets.isEmpty();
  12.360 -
  12.361 -            final int     low         = hasReturn ? 0 : 1;
  12.362 -            final int     labelCount  = targetCount + 1 - low;
  12.363 -            final Label[] labels      = new Label[labelCount];
  12.364 -
  12.365 -            for (int i = 0; i < labelCount; i++) {
  12.366 -                labels[i] = new Label(i == 0 ? "split_return" : "split_" + targets.get(i - 1));
  12.367 -            }
  12.368 -            caller.tableswitch(low, targetCount, breakLabel, labels);
  12.369 -            for (int i = low; i <= targetCount; i++) {
  12.370 -                caller.label(labels[i - low]);
  12.371 -                if (i == 0) {
  12.372 -                    caller.loadCompilerConstant(RETURN, returnType);
  12.373 -                    caller._return(returnType);
  12.374 -                } else {
  12.375 -                    final BreakableNode targetNode = targetNodes.get(i - 1);
  12.376 -                    final Label label = targets.get(i - 1);
  12.377 -                    if (!lc.isExternalTarget(splitNode, targetNode)) {
  12.378 -                        final JoinPredecessor jumpOrigin = splitNode.getJumpOrigin(label);
  12.379 -                        if(jumpOrigin != null) {
  12.380 -                            method.beforeJoinPoint(jumpOrigin);
  12.381 -                        }
  12.382 -                        popScopesUntil(targetNode);
  12.383 -                    }
  12.384 -                    caller.splitAwareGoto(lc, label, targetNode);
  12.385 -                }
  12.386 -            }
  12.387 -            caller.label(breakLabel);
  12.388 -        }
  12.389 -
  12.390 -        // If split has a return and caller is itself a split method it needs to propagate the return.
  12.391 -        if (hasReturn) {
  12.392 -            caller.setHasReturn();
  12.393 -        }
  12.394 -
  12.395 -        return splitNode;
  12.396 +    public boolean enterSplitReturn(final SplitReturn splitReturn) {
  12.397 +        if (method.isReachable()) {
  12.398 +            method.loadUndefined(lc.getCurrentFunction().getReturnType())._return();
  12.399 +        }
  12.400 +        return false;
  12.401 +    }
  12.402 +
  12.403 +    @Override
  12.404 +    public boolean enterSetSplitState(final SetSplitState setSplitState) {
  12.405 +        if (method.isReachable()) {
  12.406 +            method.setSplitState(setSplitState.getState());
  12.407 +        }
  12.408 +        return false;
  12.409      }
  12.410  
  12.411      @Override
  12.412 @@ -3678,13 +3564,15 @@
  12.413              void loadStack() {
  12.414                  final TypeBounds operandBounds;
  12.415                  final boolean isOptimistic = isValid(getProgramPoint());
  12.416 +                boolean forceConversionSeparation = false;
  12.417                  if(isOptimistic) {
  12.418                      operandBounds = new TypeBounds(binaryNode.getType(), Type.OBJECT);
  12.419                  } else {
  12.420                      // Non-optimistic, non-FP +. Allow it to overflow.
  12.421                      operandBounds = new TypeBounds(binaryNode.getWidestOperandType(), Type.OBJECT);
  12.422 +                    forceConversionSeparation = binaryNode.getWidestOperationType().narrowerThan(resultBounds.widest);
  12.423                  }
  12.424 -                loadBinaryOperands(binaryNode.lhs(), binaryNode.rhs(), operandBounds, false);
  12.425 +                loadBinaryOperands(binaryNode.lhs(), binaryNode.rhs(), operandBounds, false, forceConversionSeparation);
  12.426              }
  12.427  
  12.428              @Override
  12.429 @@ -3795,12 +3683,21 @@
  12.430          @Override
  12.431          protected void evaluate() {
  12.432              final Expression lhs = assignNode.lhs();
  12.433 -            final Type widest = assignNode.isTokenType(TokenType.ASSIGN_ADD) ? Type.OBJECT : assignNode.getWidestOperationType();
  12.434 +            final Expression rhs = assignNode.rhs();
  12.435 +            final Type widestOperationType = assignNode.getWidestOperationType();
  12.436 +            final Type widest = assignNode.isTokenType(TokenType.ASSIGN_ADD) ? Type.OBJECT : widestOperationType;
  12.437              final TypeBounds bounds = new TypeBounds(assignNode.getType(), widest);
  12.438              new OptimisticOperation(assignNode, bounds) {
  12.439                  @Override
  12.440                  void loadStack() {
  12.441 -                    loadBinaryOperands(lhs, assignNode.rhs(), bounds, true);
  12.442 +                    final boolean forceConversionSeparation;
  12.443 +                    if (isValid(getProgramPoint()) || widestOperationType == Type.NUMBER) {
  12.444 +                        forceConversionSeparation = false;
  12.445 +                    } else {
  12.446 +                        final Type operandType = Type.widest(booleanToInt(objectToNumber(lhs.getType())), booleanToInt(objectToNumber(rhs.getType())));
  12.447 +                        forceConversionSeparation = operandType.narrowerThan(widestOperationType);
  12.448 +                    }
  12.449 +                    loadBinaryOperands(lhs, rhs, bounds, true, forceConversionSeparation);
  12.450                  }
  12.451                  @Override
  12.452                  void consumeStack() {
  12.453 @@ -3823,7 +3720,7 @@
  12.454  
  12.455          @Override
  12.456          protected void evaluate() {
  12.457 -            loadBinaryOperands(assignNode.lhs(), assignNode.rhs(), TypeBounds.UNBOUNDED.notWiderThan(assignNode.getWidestOperandType()), true);
  12.458 +            loadBinaryOperands(assignNode.lhs(), assignNode.rhs(), TypeBounds.UNBOUNDED.notWiderThan(assignNode.getWidestOperandType()), true, false);
  12.459              op();
  12.460          }
  12.461      }
  12.462 @@ -3922,7 +3819,12 @@
  12.463  
  12.464      private void doSHR() {
  12.465          // TODO: make SHR optimistic
  12.466 -        method.shr().convert(Type.LONG).load(JSType.MAX_UINT).and();
  12.467 +        method.shr();
  12.468 +        toUint();
  12.469 +    }
  12.470 +
  12.471 +    private void toUint() {
  12.472 +        JSType.TO_UINT32_I.invoke(method);
  12.473      }
  12.474  
  12.475      private void loadASSIGN_SUB(final BinaryNode binaryNode) {
  12.476 @@ -3946,6 +3848,7 @@
  12.477                  @Override
  12.478                  void loadStack() {
  12.479                      final TypeBounds operandBounds;
  12.480 +                    boolean forceConversionSeparation = false;
  12.481                      if(numericBounds.narrowest == Type.NUMBER) {
  12.482                          // Result should be double always. Propagate it into the operands so we don't have lots of I2D
  12.483                          // and L2D after operand evaluation.
  12.484 @@ -3963,9 +3866,10 @@
  12.485                              // Non-optimistic, non-FP subtraction or multiplication. Allow them to overflow.
  12.486                              operandBounds = new TypeBounds(Type.narrowest(node.getWidestOperandType(),
  12.487                                      numericBounds.widest), Type.NUMBER);
  12.488 +                            forceConversionSeparation = node.getWidestOperationType().narrowerThan(numericBounds.widest);
  12.489                          }
  12.490                      }
  12.491 -                    loadBinaryOperands(node.lhs(), node.rhs(), operandBounds, false);
  12.492 +                    loadBinaryOperands(node.lhs(), node.rhs(), operandBounds, false, forceConversionSeparation);
  12.493                  }
  12.494  
  12.495                  @Override
  12.496 @@ -3982,8 +3886,18 @@
  12.497      }
  12.498  
  12.499      private void loadBIT_OR(final BinaryNode binaryNode) {
  12.500 -        loadBinaryOperands(binaryNode);
  12.501 -        method.or();
  12.502 +        // Optimize x|0 to (int)x
  12.503 +        if (isRhsZero(binaryNode)) {
  12.504 +            loadExpressionAsType(binaryNode.lhs(), Type.INT);
  12.505 +        } else {
  12.506 +            loadBinaryOperands(binaryNode);
  12.507 +            method.or();
  12.508 +        }
  12.509 +    }
  12.510 +
  12.511 +    private static boolean isRhsZero(final BinaryNode binaryNode) {
  12.512 +        final Expression rhs = binaryNode.rhs();
  12.513 +        return rhs instanceof LiteralNode && INT_ZERO.equals(((LiteralNode)rhs).getValue());
  12.514      }
  12.515  
  12.516      private void loadBIT_XOR(final BinaryNode binaryNode) {
  12.517 @@ -4060,8 +3974,14 @@
  12.518      }
  12.519  
  12.520      private void loadSHR(final BinaryNode binaryNode) {
  12.521 -        loadBinaryOperands(binaryNode);
  12.522 -        doSHR();
  12.523 +        // Optimize x >>> 0 to (uint)x
  12.524 +        if (isRhsZero(binaryNode)) {
  12.525 +            loadExpressionAsType(binaryNode.lhs(), Type.INT);
  12.526 +            toUint();
  12.527 +        } else {
  12.528 +            loadBinaryOperands(binaryNode);
  12.529 +            doSHR();
  12.530 +        }
  12.531      }
  12.532  
  12.533      private void loadSUB(final BinaryNode binaryNode, final TypeBounds resultBounds) {
  12.534 @@ -4379,11 +4299,7 @@
  12.535      private void newFunctionObject(final FunctionNode functionNode, final boolean addInitializer) {
  12.536          assert lc.peek() == functionNode;
  12.537  
  12.538 -        final int fnId = functionNode.getId();
  12.539 -
  12.540 -        final RecompilableScriptFunctionData data = compiler.getScriptFunctionData(fnId);
  12.541 -
  12.542 -        assert data != null : functionNode.getName() + " has no data";
  12.543 +        final RecompilableScriptFunctionData data = compiler.getScriptFunctionData(functionNode.getId());
  12.544  
  12.545          if (functionNode.isProgram() && !compiler.isOnDemandCompilation()) {
  12.546              final CompileUnit fnUnit = functionNode.getCompileUnit();

    13.1 --- a/src/jdk/nashorn/internal/codegen/CompilationPhase.java	Mon Oct 27 14:36:13 2014 -0700
    13.2 +++ b/src/jdk/nashorn/internal/codegen/CompilationPhase.java	Thu Nov 06 09:50:15 2014 -0800
    13.3 @@ -38,12 +38,11 @@
    13.4  import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.SPLIT;
    13.5  import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.SYMBOLS_ASSIGNED;
    13.6  import static jdk.nashorn.internal.runtime.logging.DebugLogger.quote;
    13.7 +
    13.8  import java.io.PrintWriter;
    13.9 -import java.util.ArrayList;
   13.10  import java.util.EnumSet;
   13.11  import java.util.HashMap;
   13.12  import java.util.LinkedHashMap;
   13.13 -import java.util.List;
   13.14  import java.util.Map;
   13.15  import java.util.Map.Entry;
   13.16  import java.util.Set;
   13.17 @@ -53,10 +52,7 @@
   13.18  import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
   13.19  import jdk.nashorn.internal.ir.LexicalContext;
   13.20  import jdk.nashorn.internal.ir.LiteralNode;
   13.21 -import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
   13.22 -import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;
   13.23  import jdk.nashorn.internal.ir.Node;
   13.24 -import jdk.nashorn.internal.ir.SplitNode;
   13.25  import jdk.nashorn.internal.ir.debug.ASTWriter;
   13.26  import jdk.nashorn.internal.ir.debug.PrintVisitor;
   13.27  import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   13.28 @@ -81,7 +77,7 @@
   13.29                  PARSED)) {
   13.30          @Override
   13.31          FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
   13.32 -            return (FunctionNode)fn.accept(new FoldConstants(compiler));
   13.33 +            return transformFunction(fn, new FoldConstants(compiler));
   13.34          }
   13.35  
   13.36          @Override
   13.37 @@ -104,7 +100,7 @@
   13.38                  CONSTANT_FOLDED)) {
   13.39          @Override
   13.40          FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
   13.41 -            return (FunctionNode)fn.accept(new Lower(compiler));
   13.42 +            return transformFunction(fn, new Lower(compiler));
   13.43          }
   13.44  
   13.45          @Override
   13.46 @@ -118,23 +114,6 @@
   13.47       * optimistic ops a program point so that an UnwarrantedException knows from where
   13.48       * a guess went wrong when creating the continuation to roll back this execution
   13.49       */
   13.50 -    PROGRAM_POINT_PHASE(
   13.51 -            EnumSet.of(
   13.52 -                INITIALIZED,
   13.53 -                PARSED,
   13.54 -                CONSTANT_FOLDED,
   13.55 -                LOWERED)) {
   13.56 -        @Override
   13.57 -        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
   13.58 -            return (FunctionNode)fn.accept(new ProgramPoints());
   13.59 -        }
   13.60 -
   13.61 -        @Override
   13.62 -        public String toString() {
   13.63 -            return "'Program Point Calculation'";
   13.64 -        }
   13.65 -    },
   13.66 -
   13.67      TRANSFORM_BUILTINS_PHASE(
   13.68              EnumSet.of(
   13.69                      INITIALIZED,
   13.70 @@ -144,13 +123,7 @@
   13.71          //we only do this if we have a param type map, otherwise this is not a specialized recompile
   13.72          @Override
   13.73          FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
   13.74 -            final FunctionNode newFunctionNode = (FunctionNode)fn.accept(new ApplySpecialization(compiler));
   13.75 -            return (FunctionNode)newFunctionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   13.76 -                @Override
   13.77 -                public Node leaveFunctionNode(final FunctionNode node) {
   13.78 -                    return node.setState(lc, BUILTINS_TRANSFORMED);
   13.79 -                }
   13.80 -            });
   13.81 +            return setStates(transformFunction(fn, new ApplySpecialization(compiler)), BUILTINS_TRANSFORMED);
   13.82          }
   13.83  
   13.84          @Override
   13.85 @@ -177,7 +150,7 @@
   13.86              FunctionNode newFunctionNode;
   13.87  
   13.88              //ensure elementTypes, postsets and presets exist for splitter and arraynodes
   13.89 -            newFunctionNode = (FunctionNode)fn.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   13.90 +            newFunctionNode = transformFunction(fn, new NodeVisitor<LexicalContext>(new LexicalContext()) {
   13.91                  @Override
   13.92                  public LiteralNode<?> leaveLiteralNode(final LiteralNode<?> literalNode) {
   13.93                      return literalNode.initialize(lc);
   13.94 @@ -185,7 +158,7 @@
   13.95              });
   13.96  
   13.97              newFunctionNode = new Splitter(compiler, newFunctionNode, outermostCompileUnit).split(newFunctionNode, true);
   13.98 -
   13.99 +            newFunctionNode = transformFunction(newFunctionNode, new SplitIntoFunctions(compiler));
  13.100              assert newFunctionNode.getCompileUnit() == outermostCompileUnit : "fn=" + fn.getName() + ", fn.compileUnit (" + newFunctionNode.getCompileUnit() + ") != " + outermostCompileUnit;
  13.101              assert newFunctionNode.isStrict() == compiler.isStrict() : "functionNode.isStrict() != compiler.isStrict() for " + quote(newFunctionNode.getName());
  13.102  
  13.103 @@ -198,6 +171,52 @@
  13.104          }
  13.105      },
  13.106  
  13.107 +    PROGRAM_POINT_PHASE(
  13.108 +            EnumSet.of(
  13.109 +                    INITIALIZED,
  13.110 +                    PARSED,
  13.111 +                    CONSTANT_FOLDED,
  13.112 +                    LOWERED,
  13.113 +                    BUILTINS_TRANSFORMED,
  13.114 +                    SPLIT)) {
  13.115 +        @Override
  13.116 +        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
  13.117 +            return transformFunction(fn, new ProgramPoints());
  13.118 +        }
  13.119 +
  13.120 +        @Override
  13.121 +        public String toString() {
  13.122 +            return "'Program Point Calculation'";
  13.123 +        }
  13.124 +    },
  13.125 +
  13.126 +    SERIALIZE_SPLIT_PHASE(
  13.127 +            EnumSet.of(
  13.128 +                    INITIALIZED,
  13.129 +                    PARSED,
  13.130 +                    CONSTANT_FOLDED,
  13.131 +                    LOWERED,
  13.132 +                    BUILTINS_TRANSFORMED,
  13.133 +                    SPLIT)) {
  13.134 +        @Override
  13.135 +        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
  13.136 +            return transformFunction(fn, new NodeVisitor<LexicalContext>(new LexicalContext()) {
  13.137 +                @Override
  13.138 +                public boolean enterFunctionNode(final FunctionNode functionNode) {
  13.139 +                    if (functionNode.isSplit()) {
  13.140 +                        compiler.serializeAst(functionNode);
  13.141 +                    }
  13.142 +                    return true;
  13.143 +                }
  13.144 +            });
  13.145 +        }
  13.146 +
  13.147 +        @Override
  13.148 +        public String toString() {
  13.149 +            return "'Serialize Split Functions'";
  13.150 +        }
  13.151 +    },
  13.152 +
  13.153      SYMBOL_ASSIGNMENT_PHASE(
  13.154              EnumSet.of(
  13.155                      INITIALIZED,
  13.156 @@ -208,7 +227,7 @@
  13.157                      SPLIT)) {
  13.158          @Override
  13.159          FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
  13.160 -            return (FunctionNode)fn.accept(new AssignSymbols(compiler));
  13.161 +            return transformFunction(fn, new AssignSymbols(compiler));
  13.162          }
  13.163  
  13.164          @Override
  13.165 @@ -228,7 +247,7 @@
  13.166                      SYMBOLS_ASSIGNED)) {
  13.167          @Override
  13.168          FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
  13.169 -            return (FunctionNode)fn.accept(new FindScopeDepths(compiler));
  13.170 +            return transformFunction(fn, new FindScopeDepths(compiler));
  13.171          }
  13.172  
  13.173          @Override
  13.174 @@ -250,7 +269,7 @@
  13.175          @Override
  13.176          FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
  13.177              if (compiler.useOptimisticTypes()) {
  13.178 -                return (FunctionNode)fn.accept(new OptimisticTypesCalculator(compiler));
  13.179 +                return transformFunction(fn, new OptimisticTypesCalculator(compiler));
  13.180              }
  13.181              return setStates(fn, OPTIMISTIC_TYPES_ASSIGNED);
  13.182          }
  13.183 @@ -274,8 +293,7 @@
  13.184                      OPTIMISTIC_TYPES_ASSIGNED)) {
  13.185          @Override
  13.186          FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
  13.187 -            final FunctionNode newFunctionNode = (FunctionNode)fn.accept(new LocalVariableTypesCalculator(compiler));
  13.188 -
  13.189 +            final FunctionNode newFunctionNode = transformFunction(fn, new LocalVariableTypesCalculator(compiler));
  13.190              final ScriptEnvironment senv = compiler.getScriptEnvironment();
  13.191              final PrintWriter       err  = senv.getErr();
  13.192  
  13.193 @@ -330,13 +348,7 @@
  13.194  
  13.195              for (final CompileUnit oldUnit : compiler.getCompileUnits()) {
  13.196                  assert map.get(oldUnit) == null;
  13.197 -                final StringBuilder sb = new StringBuilder(compiler.nextCompileUnitName());
  13.198 -                if (phases.isRestOfCompilation()) {
  13.199 -                    sb.append("$restOf");
  13.200 -                }
  13.201 -                //it's ok to not copy the initCount, methodCount and clinitCount here, as codegen is what
  13.202 -                //fills those out anyway. Thus no need for a copy constructor
  13.203 -                final CompileUnit newUnit = compiler.createCompileUnit(sb.toString(), oldUnit.getWeight());
  13.204 +                final CompileUnit newUnit = createNewCompileUnit(compiler, phases);
  13.205                  log.fine("Creating new compile unit ", oldUnit, " => ", newUnit);
  13.206                  map.put(oldUnit, newUnit);
  13.207                  assert newUnit != null;
  13.208 @@ -350,47 +362,10 @@
  13.209              //replace old compile units in function nodes, if any are assigned,
  13.210              //for example by running the splitter on this function node in a previous
  13.211              //partial code generation
  13.212 -            final FunctionNode newFunctionNode = (FunctionNode)fn.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  13.213 +            final FunctionNode newFunctionNode = transformFunction(fn, new ReplaceCompileUnits() {
  13.214                  @Override
  13.215 -                public Node leaveFunctionNode(final FunctionNode node) {
  13.216 -                    final CompileUnit oldUnit = node.getCompileUnit();
  13.217 -                    assert oldUnit != null : "no compile unit in function node";
  13.218 -
  13.219 -                    final CompileUnit newUnit = map.get(oldUnit);
  13.220 -                    assert newUnit != null : "old unit has no mapping to new unit " + oldUnit;
  13.221 -
  13.222 -                    log.fine("Replacing compile unit: ", oldUnit, " => ", newUnit, " in ", quote(node.getName()));
  13.223 -                    return node.setCompileUnit(lc, newUnit).setState(lc, CompilationState.COMPILE_UNITS_REUSED);
  13.224 -                }
  13.225 -
  13.226 -                @Override
  13.227 -                public Node leaveSplitNode(final SplitNode node) {
  13.228 -                    final CompileUnit oldUnit = node.getCompileUnit();
  13.229 -                    assert oldUnit != null : "no compile unit in function node";
  13.230 -
  13.231 -                    final CompileUnit newUnit = map.get(oldUnit);
  13.232 -                    assert newUnit != null : "old unit has no mapping to new unit " + oldUnit;
  13.233 -
  13.234 -                    log.fine("Replacing compile unit: ", oldUnit, " => ", newUnit, " in ", quote(node.getName()));
  13.235 -                    return node.setCompileUnit(lc, newUnit);
  13.236 -                }
  13.237 -
  13.238 -                @Override
  13.239 -                public Node leaveLiteralNode(final LiteralNode<?> node) {
  13.240 -                    if (node instanceof ArrayLiteralNode) {
  13.241 -                        final ArrayLiteralNode aln = (ArrayLiteralNode)node;
  13.242 -                        if (aln.getUnits() == null) {
  13.243 -                            return node;
  13.244 -                        }
  13.245 -                        final List<ArrayUnit> newArrayUnits = new ArrayList<>();
  13.246 -                        for (final ArrayUnit au : aln.getUnits()) {
  13.247 -                            final CompileUnit newUnit = map.get(au.getCompileUnit());
  13.248 -                            assert newUnit != null;
  13.249 -                            newArrayUnits.add(new ArrayUnit(newUnit, au.getLo(), au.getHi()));
  13.250 -                        }
  13.251 -                        return aln.setUnits(lc, newArrayUnits);
  13.252 -                    }
  13.253 -                    return node;
  13.254 +                CompileUnit getReplacement(CompileUnit original) {
  13.255 +                    return map.get(original);
  13.256                  }
  13.257  
  13.258                  @Override
  13.259 @@ -408,7 +383,59 @@
  13.260          }
  13.261      },
  13.262  
  13.263 -     /**
  13.264 +    REINITIALIZE_SERIALIZED(
  13.265 +            EnumSet.of(
  13.266 +                    INITIALIZED,
  13.267 +                    PARSED,
  13.268 +                    CONSTANT_FOLDED,
  13.269 +                    LOWERED,
  13.270 +                    BUILTINS_TRANSFORMED,
  13.271 +                    SPLIT)) {
  13.272 +        @Override
  13.273 +        FunctionNode transform(final Compiler compiler, final CompilationPhases phases, final FunctionNode fn) {
  13.274 +            final Set<CompileUnit> unitSet = CompileUnit.createCompileUnitSet();
  13.275 +            final Map<CompileUnit, CompileUnit> unitMap = new HashMap<>();
  13.276 +
  13.277 +            // Ensure that the FunctionNode's compile unit is the first in the list of new units. Install phase
  13.278 +            // will use that as the root class.
  13.279 +            createCompileUnit(fn.getCompileUnit(), unitSet, unitMap, compiler, phases);
  13.280 +
  13.281 +            final FunctionNode newFn = transformFunction(fn, new ReplaceCompileUnits() {
  13.282 +                @Override
  13.283 +                CompileUnit getReplacement(final CompileUnit oldUnit) {
  13.284 +                    final CompileUnit existing = unitMap.get(oldUnit);
  13.285 +                    if (existing != null) {
  13.286 +                        return existing;
  13.287 +                    }
  13.288 +                    return createCompileUnit(oldUnit, unitSet, unitMap, compiler, phases);
  13.289 +                }
  13.290 +
  13.291 +                @Override
  13.292 +                public Node leaveFunctionNode(final FunctionNode fn2) {
  13.293 +                    return super.leaveFunctionNode(
  13.294 +                            // restore flags for deserialized nested function nodes
  13.295 +                            compiler.getScriptFunctionData(fn2.getId()).restoreFlags(lc, fn2));
  13.296 +                };
  13.297 +            });
  13.298 +            compiler.replaceCompileUnits(unitSet);
  13.299 +            return newFn;
  13.300 +        }
  13.301 +
  13.302 +        private CompileUnit createCompileUnit(final CompileUnit oldUnit, final Set<CompileUnit> unitSet,
  13.303 +                final Map<CompileUnit, CompileUnit> unitMap, final Compiler compiler, final CompilationPhases phases) {
  13.304 +            final CompileUnit newUnit = createNewCompileUnit(compiler, phases);
  13.305 +            unitMap.put(oldUnit, newUnit);
  13.306 +            unitSet.add(newUnit);
  13.307 +            return newUnit;
  13.308 +        }
  13.309 +
  13.310 +        @Override
  13.311 +        public String toString() {
  13.312 +            return "'Deserialize'";
  13.313 +        }
  13.314 +    },
  13.315 +
  13.316 +    /**
  13.317       * Bytecode generation:
  13.318       *
  13.319       * Generate the byte code class(es) resulting from the compiled FunctionNode
  13.320 @@ -443,7 +470,7 @@
  13.321              try {
  13.322                  // Explicitly set BYTECODE_GENERATED here; it can not be set in case of skipping codegen for :program
  13.323                  // in the lazy + optimistic world. See CodeGenerator.skipFunction().
  13.324 -                newFunctionNode = ((FunctionNode)newFunctionNode.accept(codegen)).setState(null, BYTECODE_GENERATED);
  13.325 +                newFunctionNode = transformFunction(newFunctionNode, codegen).setState(null, BYTECODE_GENERATED);
  13.326                  codegen.generateScopeCalls();
  13.327              } catch (final VerifyError e) {
  13.328                  if (senv._verify_code || senv._print_code) {
  13.329 @@ -615,7 +642,7 @@
  13.330          if (!AssertsEnabled.assertsEnabled()) {
  13.331              return functionNode;
  13.332          }
  13.333 -        return (FunctionNode)functionNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
  13.334 +        return transformFunction(functionNode, new NodeVisitor<LexicalContext>(new LexicalContext()) {
  13.335              @Override
  13.336              public Node leaveFunctionNode(final FunctionNode fn) {
  13.337                  return fn.setState(lc, state);
  13.338 @@ -701,4 +728,17 @@
  13.339          return end(compiler, transform(compiler, phases, begin(compiler, functionNode)));
  13.340      }
  13.341  
  13.342 +    private static FunctionNode transformFunction(final FunctionNode fn, final NodeVisitor<?> visitor) {
  13.343 +        return (FunctionNode) fn.accept(visitor);
  13.344 +    }
  13.345 +
  13.346 +    private static CompileUnit createNewCompileUnit(final Compiler compiler, final CompilationPhases phases) {
  13.347 +        final StringBuilder sb = new StringBuilder(compiler.nextCompileUnitName());
  13.348 +        if (phases.isRestOfCompilation()) {
  13.349 +            sb.append("$restOf");
  13.350 +        }
  13.351 +        //it's ok to not copy the initCount, methodCount and clinitCount here, as codegen is what
  13.352 +        //fills those out anyway. Thus no need for a copy constructor
  13.353 +        return compiler.createCompileUnit(sb.toString(), 0);
  13.354 +    }
  13.355  }

    14.1 --- a/src/jdk/nashorn/internal/codegen/CompileUnit.java	Mon Oct 27 14:36:13 2014 -0700
    14.2 +++ b/src/jdk/nashorn/internal/codegen/CompileUnit.java	Thu Nov 06 09:50:15 2014 -0800
    14.3 @@ -25,24 +25,31 @@
    14.4  
    14.5  package jdk.nashorn.internal.codegen;
    14.6  
    14.7 +import java.io.Serializable;
    14.8  import java.util.Set;
    14.9  import java.util.TreeSet;
   14.10 +import jdk.nashorn.internal.ir.CompileUnitHolder;
   14.11  
   14.12  /**
   14.13 - * Used to track split class compilation.
   14.14 - */
   14.15 -public final class CompileUnit implements Comparable<CompileUnit> {
   14.16 +  * Used to track split class compilation. Note that instances of the class are serializable, but all fields are
   14.17 +  * transient, making the serialized version of the class only useful for tracking the referential topology of other
   14.18 +  * AST nodes referencing the same or different compile units. We do want to preserve this topology though as
   14.19 +  * {@link CompileUnitHolder}s in a deserialized AST will undergo reinitialization.
   14.20 +  */
   14.21 +public final class CompileUnit implements Comparable<CompileUnit>, Serializable {
   14.22 +    private static final long serialVersionUID = 1L;
   14.23 +
   14.24      /** Current class name */
   14.25 -    private final String className;
   14.26 +    private transient final String className;
   14.27  
   14.28      /** Current class generator */
   14.29 -    private ClassEmitter classEmitter;
   14.30 +    private transient ClassEmitter classEmitter;
   14.31  
   14.32 -    private long weight;
   14.33 +    private transient long weight;
   14.34  
   14.35 -    private Class<?> clazz;
   14.36 +    private transient Class<?> clazz;
   14.37  
   14.38 -    private boolean isUsed;
   14.39 +    private transient boolean isUsed;
   14.40  
   14.41      private static int emittedUnitCount;
   14.42  
   14.43 @@ -122,14 +129,6 @@
   14.44      }
   14.45  
   14.46      /**
   14.47 -     * Get the current weight of the compile unit.
   14.48 -     * @return the unit's weight
   14.49 -     */
   14.50 -    long getWeight() {
   14.51 -        return weight;
   14.52 -    }
   14.53 -
   14.54 -    /**
   14.55       * Check if this compile unit can hold {@code weight} more units of weight
   14.56       * @param w weight to check if can be added
   14.57       * @return true if weight fits in this compile unit
   14.58 @@ -155,7 +154,7 @@
   14.59      }
   14.60  
   14.61      private static String shortName(final String name) {
   14.62 -        return name.lastIndexOf('/') == -1 ? name : name.substring(name.lastIndexOf('/') + 1);
   14.63 +        return name == null ? null : name.lastIndexOf('/') == -1 ? name : name.substring(name.lastIndexOf('/') + 1);
   14.64      }
   14.65  
   14.66      @Override

    15.1 --- a/src/jdk/nashorn/internal/codegen/Compiler.java	Mon Oct 27 14:36:13 2014 -0700
    15.2 +++ b/src/jdk/nashorn/internal/codegen/Compiler.java	Thu Nov 06 09:50:15 2014 -0800
    15.3 @@ -32,15 +32,16 @@
    15.4  import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
    15.5  import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
    15.6  import static jdk.nashorn.internal.runtime.logging.DebugLogger.quote;
    15.7 +
    15.8  import java.io.File;
    15.9  import java.lang.invoke.MethodType;
   15.10 +import java.util.ArrayList;
   15.11  import java.util.Arrays;
   15.12  import java.util.Collections;
   15.13  import java.util.Comparator;
   15.14  import java.util.HashMap;
   15.15  import java.util.Iterator;
   15.16  import java.util.LinkedHashMap;
   15.17 -import java.util.LinkedList;
   15.18  import java.util.List;
   15.19  import java.util.Map;
   15.20  import java.util.Set;
   15.21 @@ -159,75 +160,142 @@
   15.22       */
   15.23      private static final int COMPILE_UNIT_NAME_BUFFER_SIZE = 32;
   15.24  
   15.25 +    private final Map<Integer, byte[]> serializedAsts = new HashMap<>();
   15.26 +
   15.27      /**
   15.28       * Compilation phases that a compilation goes through
   15.29       */
   15.30      public static class CompilationPhases implements Iterable<CompilationPhase> {
   15.31  
   15.32 -        /** Singleton that describes a standard eager compilation - this includes code installation */
   15.33 -        public final static CompilationPhases COMPILE_ALL = new CompilationPhases(
   15.34 -                "Compile all",
   15.35 -                new CompilationPhase[] {
   15.36 -                        CompilationPhase.CONSTANT_FOLDING_PHASE,
   15.37 -                        CompilationPhase.LOWERING_PHASE,
   15.38 -                        CompilationPhase.PROGRAM_POINT_PHASE,
   15.39 -                        CompilationPhase.TRANSFORM_BUILTINS_PHASE,
   15.40 -                        CompilationPhase.SPLITTING_PHASE,
   15.41 -                        CompilationPhase.SYMBOL_ASSIGNMENT_PHASE,
   15.42 -                        CompilationPhase.SCOPE_DEPTH_COMPUTATION_PHASE,
   15.43 -                        CompilationPhase.OPTIMISTIC_TYPE_ASSIGNMENT_PHASE,
   15.44 -                        CompilationPhase.LOCAL_VARIABLE_TYPE_CALCULATION_PHASE,
   15.45 -                        CompilationPhase.BYTECODE_GENERATION_PHASE,
   15.46 -                        CompilationPhase.INSTALL_PHASE
   15.47 -                });
   15.48 +        /**
   15.49 +         * Singleton that describes compilation up to the phase where a function can be serialized.
   15.50 +         */
   15.51 +        private final static CompilationPhases COMPILE_UPTO_SERIALIZABLE = new CompilationPhases(
   15.52 +                "Common initial phases",
   15.53 +                CompilationPhase.CONSTANT_FOLDING_PHASE,
   15.54 +                CompilationPhase.LOWERING_PHASE,
   15.55 +                CompilationPhase.TRANSFORM_BUILTINS_PHASE,
   15.56 +                CompilationPhase.SPLITTING_PHASE,
   15.57 +                CompilationPhase.PROGRAM_POINT_PHASE,
   15.58 +                CompilationPhase.SERIALIZE_SPLIT_PHASE
   15.59 +                );
   15.60  
   15.61 -        /** Compile all for a rest of method */
   15.62 -        public final static CompilationPhases COMPILE_ALL_RESTOF =
   15.63 -                COMPILE_ALL.setDescription("Compile all, rest of").addAfter(CompilationPhase.LOCAL_VARIABLE_TYPE_CALCULATION_PHASE, CompilationPhase.REUSE_COMPILE_UNITS_PHASE);
   15.64 +        private final static CompilationPhases COMPILE_SERIALIZABLE_UPTO_BYTECODE = new CompilationPhases(
   15.65 +                "After common phases, before bytecode generator",
   15.66 +                CompilationPhase.SYMBOL_ASSIGNMENT_PHASE,
   15.67 +                CompilationPhase.SCOPE_DEPTH_COMPUTATION_PHASE,
   15.68 +                CompilationPhase.OPTIMISTIC_TYPE_ASSIGNMENT_PHASE,
   15.69 +                CompilationPhase.LOCAL_VARIABLE_TYPE_CALCULATION_PHASE
   15.70 +                );
   15.71  
   15.72 -        /** Singleton that describes a standard eager compilation, but no installation, for example used by --compile-only */
   15.73 -        public final static CompilationPhases COMPILE_ALL_NO_INSTALL =
   15.74 -                COMPILE_ALL.
   15.75 -                removeLast().
   15.76 -                setDescription("Compile without install");
   15.77 -
   15.78 -        /** Singleton that describes compilation up to the CodeGenerator, but not actually generating code */
   15.79 -        public final static CompilationPhases COMPILE_UPTO_BYTECODE =
   15.80 -                COMPILE_ALL.
   15.81 -                removeLast().
   15.82 -                removeLast().
   15.83 -                setDescription("Compile upto bytecode");
   15.84 +        /**
   15.85 +         * Singleton that describes additional steps to be taken after deserializing, all the way up to (but not
   15.86 +         * including) generating and installing code.
   15.87 +         */
   15.88 +        public final static CompilationPhases RECOMPILE_SERIALIZED_UPTO_BYTECODE = new CompilationPhases(
   15.89 +                "Recompile serialized function up to bytecode",
   15.90 +                CompilationPhase.REINITIALIZE_SERIALIZED,
   15.91 +                COMPILE_SERIALIZABLE_UPTO_BYTECODE
   15.92 +                );
   15.93  
   15.94          /**
   15.95           * Singleton that describes back end of method generation, given that we have generated the normal
   15.96           * method up to CodeGenerator as in {@link CompilationPhases#COMPILE_UPTO_BYTECODE}
   15.97           */
   15.98 -        public final static CompilationPhases COMPILE_FROM_BYTECODE = new CompilationPhases(
   15.99 +        public final static CompilationPhases GENERATE_BYTECODE_AND_INSTALL = new CompilationPhases(
  15.100                  "Generate bytecode and install",
  15.101 -                new CompilationPhase[] {
  15.102 -                        CompilationPhase.BYTECODE_GENERATION_PHASE,
  15.103 -                        CompilationPhase.INSTALL_PHASE
  15.104 -                });
  15.105 +                CompilationPhase.BYTECODE_GENERATION_PHASE,
  15.106 +                CompilationPhase.INSTALL_PHASE
  15.107 +                );
  15.108 +
  15.109 +        /** Singleton that describes compilation up to the CodeGenerator, but not actually generating code */
  15.110 +        public final static CompilationPhases COMPILE_UPTO_BYTECODE = new CompilationPhases(
  15.111 +                "Compile upto bytecode",
  15.112 +                COMPILE_UPTO_SERIALIZABLE,
  15.113 +                COMPILE_SERIALIZABLE_UPTO_BYTECODE);
  15.114 +
  15.115 +        /** Singleton that describes a standard eager compilation, but no installation, for example used by --compile-only */
  15.116 +        public final static CompilationPhases COMPILE_ALL_NO_INSTALL = new CompilationPhases(
  15.117 +                "Compile without install",
  15.118 +                COMPILE_UPTO_BYTECODE,
  15.119 +                CompilationPhase.BYTECODE_GENERATION_PHASE);
  15.120 +
  15.121 +        /** Singleton that describes a standard eager compilation - this includes code installation */
  15.122 +        public final static CompilationPhases COMPILE_ALL = new CompilationPhases(
  15.123 +                "Full eager compilation",
  15.124 +                COMPILE_UPTO_BYTECODE,
  15.125 +                GENERATE_BYTECODE_AND_INSTALL);
  15.126 +
  15.127 +        /** Singleton that describes a full compilation - this includes code installation - from serialized state*/
  15.128 +        public final static CompilationPhases COMPILE_ALL_SERIALIZED = new CompilationPhases(
  15.129 +                "Eager compilation from serializaed state",
  15.130 +                RECOMPILE_SERIALIZED_UPTO_BYTECODE,
  15.131 +                GENERATE_BYTECODE_AND_INSTALL);
  15.132  
  15.133          /**
  15.134           * Singleton that describes restOf method generation, given that we have generated the normal
  15.135           * method up to CodeGenerator as in {@link CompilationPhases#COMPILE_UPTO_BYTECODE}
  15.136           */
  15.137 -        public final static CompilationPhases COMPILE_FROM_BYTECODE_RESTOF =
  15.138 -                COMPILE_FROM_BYTECODE.
  15.139 -                addFirst(CompilationPhase.REUSE_COMPILE_UNITS_PHASE).
  15.140 -                setDescription("Generate bytecode and install - RestOf method");
  15.141 +        public final static CompilationPhases GENERATE_BYTECODE_AND_INSTALL_RESTOF = new CompilationPhases(
  15.142 +                "Generate bytecode and install - RestOf method",
  15.143 +                CompilationPhase.REUSE_COMPILE_UNITS_PHASE,
  15.144 +                GENERATE_BYTECODE_AND_INSTALL);
  15.145 +
  15.146 +        /** Compile all for a rest of method */
  15.147 +        public final static CompilationPhases COMPILE_ALL_RESTOF = new CompilationPhases(
  15.148 +                "Compile all, rest of",
  15.149 +                COMPILE_UPTO_BYTECODE,
  15.150 +                GENERATE_BYTECODE_AND_INSTALL_RESTOF);
  15.151 +
  15.152 +        /** Compile from serialized for a rest of method */
  15.153 +        public final static CompilationPhases COMPILE_SERIALIZED_RESTOF = new CompilationPhases(
  15.154 +                "Compile serialized, rest of",
  15.155 +                RECOMPILE_SERIALIZED_UPTO_BYTECODE,
  15.156 +                GENERATE_BYTECODE_AND_INSTALL_RESTOF);
  15.157  
  15.158          private final List<CompilationPhase> phases;
  15.159  
  15.160          private final String desc;
  15.161  
  15.162          private CompilationPhases(final String desc, final CompilationPhase... phases) {
  15.163 +            this(desc, Arrays.asList(phases));
  15.164 +        }
  15.165 +
  15.166 +        private CompilationPhases(final String desc, final CompilationPhases base, final CompilationPhase... phases) {
  15.167 +            this(desc, concat(base.phases, Arrays.asList(phases)));
  15.168 +        }
  15.169 +
  15.170 +        private CompilationPhases(final String desc, final CompilationPhase first, final CompilationPhases rest) {
  15.171 +            this(desc, concat(Collections.singletonList(first), rest.phases));
  15.172 +        }
  15.173 +
  15.174 +        private CompilationPhases(final String desc, final CompilationPhases base) {
  15.175 +            this(desc, base.phases);
  15.176 +        }
  15.177 +
  15.178 +        private CompilationPhases(final String desc, final CompilationPhases... bases) {
  15.179 +            this(desc, concatPhases(bases));
  15.180 +        }
  15.181 +
  15.182 +        private CompilationPhases(final String desc, final List<CompilationPhase> phases) {
  15.183              this.desc = desc;
  15.184 +            this.phases = phases;
  15.185 +        }
  15.186  
  15.187 -            final List<CompilationPhase> newPhases = new LinkedList<>();
  15.188 -            newPhases.addAll(Arrays.asList(phases));
  15.189 -            this.phases = Collections.unmodifiableList(newPhases);
  15.190 +        private static List<CompilationPhase> concatPhases(final CompilationPhases[] bases) {
  15.191 +            final ArrayList<CompilationPhase> l = new ArrayList<>();
  15.192 +            for(final CompilationPhases base: bases) {
  15.193 +                l.addAll(base.phases);
  15.194 +            }
  15.195 +            l.trimToSize();
  15.196 +            return l;
  15.197 +        }
  15.198 +
  15.199 +        private static <T> List<T> concat(final List<T> l1, final List<T> l2) {
  15.200 +            final ArrayList<T> l = new ArrayList<>(l1);
  15.201 +            l.addAll(l2);
  15.202 +            l.trimToSize();
  15.203 +            return l;
  15.204          }
  15.205  
  15.206          @Override
  15.207 @@ -235,45 +303,6 @@
  15.208              return "'" + desc + "' " + phases.toString();
  15.209          }
  15.210  
  15.211 -        private CompilationPhases setDescription(final String desc) {
  15.212 -            return new CompilationPhases(desc, phases.toArray(new CompilationPhase[phases.size()]));
  15.213 -        }
  15.214 -
  15.215 -        private CompilationPhases removeLast() {
  15.216 -            final LinkedList<CompilationPhase> list = new LinkedList<>(phases);
  15.217 -            list.removeLast();
  15.218 -            return new CompilationPhases(desc, list.toArray(new CompilationPhase[list.size()]));
  15.219 -        }
  15.220 -
  15.221 -        private CompilationPhases addFirst(final CompilationPhase phase) {
  15.222 -            if (phases.contains(phase)) {
  15.223 -                return this;
  15.224 -            }
  15.225 -            final LinkedList<CompilationPhase> list = new LinkedList<>(phases);
  15.226 -            list.addFirst(phase);
  15.227 -            return new CompilationPhases(desc, list.toArray(new CompilationPhase[list.size()]));
  15.228 -        }
  15.229 -
  15.230 -        @SuppressWarnings("unused") //TODO I'll use this soon
  15.231 -        private CompilationPhases replace(final CompilationPhase phase, final CompilationPhase newPhase) {
  15.232 -            final LinkedList<CompilationPhase> list = new LinkedList<>();
  15.233 -            for (final CompilationPhase p : phases) {
  15.234 -                list.add(p == phase ? newPhase : p);
  15.235 -            }
  15.236 -            return new CompilationPhases(desc, list.toArray(new CompilationPhase[list.size()]));
  15.237 -        }
  15.238 -
  15.239 -        private CompilationPhases addAfter(final CompilationPhase phase, final CompilationPhase newPhase) {
  15.240 -            final LinkedList<CompilationPhase> list = new LinkedList<>();
  15.241 -            for (final CompilationPhase p : phases) {
  15.242 -                list.add(p);
  15.243 -                if (p == phase) {
  15.244 -                    list.add(newPhase);
  15.245 -                }
  15.246 -            }
  15.247 -            return new CompilationPhases(desc, list.toArray(new CompilationPhase[list.size()]));
  15.248 -        }
  15.249 -
  15.250          boolean contains(final CompilationPhase phase) {
  15.251              return phases.contains(phase);
  15.252          }
  15.253 @@ -284,7 +313,7 @@
  15.254          }
  15.255  
  15.256          boolean isRestOfCompilation() {
  15.257 -            return this == COMPILE_ALL_RESTOF || this == COMPILE_FROM_BYTECODE_RESTOF;
  15.258 +            return this == COMPILE_ALL_RESTOF || this == GENERATE_BYTECODE_AND_INSTALL_RESTOF || this == COMPILE_SERIALIZED_RESTOF;
  15.259          }
  15.260  
  15.261          String getDesc() {
  15.262 @@ -410,10 +439,29 @@
  15.263              baseName = baseName + installer.getUniqueScriptId();
  15.264          }
  15.265  
  15.266 -        final String mangled = NameCodec.encode(baseName);
  15.267 +        // ASM's bytecode verifier does not allow JVM allowed safe escapes using '\' as escape char.
  15.268 +        // While ASM accepts such escapes for method names, field names, it enforces Java identifier
  15.269 +        // for class names. Workaround that ASM bug here by replacing JVM 'dangerous' chars with '_'
  15.270 +        // rather than safe encoding using '\'.
  15.271 +        final String mangled = env._verify_code? replaceDangerChars(baseName) : NameCodec.encode(baseName);
  15.272          return mangled != null ? mangled : baseName;
  15.273      }
  15.274  
  15.275 +    private static final String DANGEROUS_CHARS   = "\\/.;:$[]<>";
  15.276 +    private static String replaceDangerChars(final String name) {
  15.277 +        final int len = name.length();
  15.278 +        final StringBuilder buf = new StringBuilder();
  15.279 +        for (int i = 0; i < len; i++) {
  15.280 +            final char ch = name.charAt(i);
  15.281 +            if (DANGEROUS_CHARS.indexOf(ch) != -1) {
  15.282 +                buf.append('_');
  15.283 +            } else {
  15.284 +                buf.append(ch);
  15.285 +            }
  15.286 +        }
  15.287 +        return buf.toString();
  15.288 +    }
  15.289 +
  15.290      private String firstCompileUnitName() {
  15.291          final StringBuilder sb = new StringBuilder(SCRIPTS_PACKAGE).
  15.292                  append('/').
  15.293 @@ -730,6 +778,14 @@
  15.294          compileUnits.addAll(newUnits);
  15.295      }
  15.296  
  15.297 +    void serializeAst(final FunctionNode fn) {
  15.298 +        serializedAsts.put(fn.getId(), AstSerializer.serialize(fn));
  15.299 +    }
  15.300 +
  15.301 +    byte[] removeSerializedAst(final int fnId) {
  15.302 +        return serializedAsts.remove(fnId);
  15.303 +    }
  15.304 +
  15.305      CompileUnit findUnit(final long weight) {
  15.306          for (final CompileUnit unit : compileUnits) {
  15.307              if (unit.canHold(weight)) {
  15.308 @@ -752,7 +808,10 @@
  15.309      }
  15.310  
  15.311      RecompilableScriptFunctionData getScriptFunctionData(final int functionId) {
  15.312 -        return compiledFunction == null ? null : compiledFunction.getScriptFunctionData(functionId);
  15.313 +        assert compiledFunction != null;
  15.314 +        final RecompilableScriptFunctionData fn = compiledFunction.getScriptFunctionData(functionId);
  15.315 +        assert fn != null : functionId;
  15.316 +        return fn;
  15.317      }
  15.318  
  15.319      boolean isGlobalSymbol(final FunctionNode fn, final String name) {

    16.1 --- a/src/jdk/nashorn/internal/codegen/FindScopeDepths.java	Mon Oct 27 14:36:13 2014 -0700
    16.2 +++ b/src/jdk/nashorn/internal/codegen/FindScopeDepths.java	Thu Nov 06 09:50:15 2014 -0800
    16.3 @@ -187,7 +187,6 @@
    16.4  
    16.5          if (compiler.isOnDemandCompilation()) {
    16.6              final RecompilableScriptFunctionData data = compiler.getScriptFunctionData(newFunctionNode.getId());
    16.7 -            assert data != null : newFunctionNode.getName() + " lacks data";
    16.8              if (data.inDynamicContext()) {
    16.9                  log.fine("Reviving scriptfunction ", quote(name), " as defined in previous (now lost) dynamic scope.");
   16.10                  newFunctionNode = newFunctionNode.setInDynamicContext(lc);
   16.11 @@ -202,7 +201,7 @@
   16.12  
   16.13          //create recompilable scriptfunctiondata
   16.14          final int fnId = newFunctionNode.getId();
   16.15 -        final Map<Integer, RecompilableScriptFunctionData> nestedFunctions = fnIdToNestedFunctions.get(fnId);
   16.16 +        final Map<Integer, RecompilableScriptFunctionData> nestedFunctions = fnIdToNestedFunctions.remove(fnId);
   16.17  
   16.18          assert nestedFunctions != null;
   16.19          // Generate the object class and property map in case this function is ever used as constructor
   16.20 @@ -212,8 +211,8 @@
   16.21                  new AllocatorDescriptor(newFunctionNode.getThisProperties()),
   16.22                  nestedFunctions,
   16.23                  externalSymbolDepths.get(fnId),
   16.24 -                internalSymbols.get(fnId)
   16.25 -                );
   16.26 +                internalSymbols.get(fnId),
   16.27 +                compiler.removeSerializedAst(fnId));
   16.28  
   16.29          if (lc.getOutermostFunction() != newFunctionNode) {
   16.30              final FunctionNode parentFn = lc.getParentFunction(newFunctionNode);

    17.1 --- a/src/jdk/nashorn/internal/codegen/FoldConstants.java	Mon Oct 27 14:36:13 2014 -0700
    17.2 +++ b/src/jdk/nashorn/internal/codegen/FoldConstants.java	Thu Nov 06 09:50:15 2014 -0800
    17.3 @@ -291,7 +291,7 @@
    17.4                  value = lhs.getNumber() - rhs.getNumber();
    17.5                  break;
    17.6              case SHR:
    17.7 -                return LiteralNode.newInstance(token, finish, (lhs.getInt32() >>> rhs.getInt32()) & JSType.MAX_UINT);
    17.8 +                return LiteralNode.newInstance(token, finish, JSType.toUint32(lhs.getInt32() >>> rhs.getInt32()));
    17.9              case SAR:
   17.10                  return LiteralNode.newInstance(token, finish, lhs.getInt32() >> rhs.getInt32());
   17.11              case SHL:

    18.1 --- a/src/jdk/nashorn/internal/codegen/Label.java	Mon Oct 27 14:36:13 2014 -0700
    18.2 +++ b/src/jdk/nashorn/internal/codegen/Label.java	Thu Nov 06 09:50:15 2014 -0800
    18.3 @@ -24,6 +24,7 @@
    18.4   */
    18.5  package jdk.nashorn.internal.codegen;
    18.6  
    18.7 +import java.io.Serializable;
    18.8  import java.util.ArrayList;
    18.9  import java.util.Arrays;
   18.10  import java.util.BitSet;
   18.11 @@ -39,7 +40,9 @@
   18.12   *
   18.13   * see -Dnashorn.codegen.debug, --log=codegen
   18.14   */
   18.15 -public final class Label {
   18.16 +public final class Label implements Serializable {
   18.17 +    private static final long serialVersionUID = 1L;
   18.18 +
   18.19      //byte code generation evaluation type stack for consistency check
   18.20      //and correct opcode selection. one per label as a label may be a
   18.21      //join point
   18.22 @@ -491,7 +494,7 @@
   18.23      private final String name;
   18.24  
   18.25      /** Type stack at this label */
   18.26 -    private Label.Stack stack;
   18.27 +    private transient Label.Stack stack;
   18.28  
   18.29      /** ASM representation of this label */
   18.30      private jdk.internal.org.objectweb.asm.Label label;
   18.31 @@ -500,9 +503,9 @@
   18.32      private final int id;
   18.33  
   18.34      /** Is this label reachable (anything ever jumped to it)? */
   18.35 -    private boolean reachable;
   18.36 +    private transient boolean reachable;
   18.37  
   18.38 -    private boolean breakTarget;
   18.39 +    private transient boolean breakTarget;
   18.40  
   18.41      /**
   18.42       * Constructor

    19.1 --- a/src/jdk/nashorn/internal/codegen/LocalVariableTypesCalculator.java	Mon Oct 27 14:36:13 2014 -0700
    19.2 +++ b/src/jdk/nashorn/internal/codegen/LocalVariableTypesCalculator.java	Thu Nov 06 09:50:15 2014 -0800
    19.3 @@ -72,7 +72,7 @@
    19.4  import jdk.nashorn.internal.ir.ReturnNode;
    19.5  import jdk.nashorn.internal.ir.RuntimeNode;
    19.6  import jdk.nashorn.internal.ir.RuntimeNode.Request;
    19.7 -import jdk.nashorn.internal.ir.SplitNode;
    19.8 +import jdk.nashorn.internal.ir.SplitReturn;
    19.9  import jdk.nashorn.internal.ir.Statement;
   19.10  import jdk.nashorn.internal.ir.SwitchNode;
   19.11  import jdk.nashorn.internal.ir.Symbol;
   19.12 @@ -361,10 +361,6 @@
   19.13      // Synthetic return node that we must insert at the end of the function if it's end is reachable.
   19.14      private ReturnNode syntheticReturn;
   19.15  
   19.16 -    // Topmost current split node (if any)
   19.17 -    private SplitNode topSplit;
   19.18 -    private boolean split;
   19.19 -
   19.20      private boolean alreadyEnteredTopLevelFunction;
   19.21  
   19.22      // LvarType and conversion information gathered during the top-down pass; applied to nodes in the bottom-up pass.
   19.23 @@ -477,22 +473,7 @@
   19.24              return false;
   19.25          }
   19.26          final BreakableNode target = jump.getTarget(lc);
   19.27 -        return splitAwareJumpToLabel(jump, target, jump.getTargetLabel(target));
   19.28 -    }
   19.29 -
   19.30 -    private boolean splitAwareJumpToLabel(final JumpStatement jumpStatement, final BreakableNode target, final Label targetLabel) {
   19.31 -        final JoinPredecessor jumpOrigin;
   19.32 -        if(topSplit != null && lc.isExternalTarget(topSplit, target)) {
   19.33 -            // If the jump target is outside the topmost split node, then we'll create a synthetic jump origin in the
   19.34 -            // split node.
   19.35 -            jumpOrigin = new JoinPredecessorExpression();
   19.36 -            topSplit.addJump(jumpOrigin, targetLabel);
   19.37 -        } else {
   19.38 -            // Otherwise, the original jump statement is the jump origin
   19.39 -            jumpOrigin = jumpStatement;
   19.40 -        }
   19.41 -
   19.42 -        jumpToLabel(jumpOrigin, targetLabel, getBreakTargetTypes(target));
   19.43 +        jumpToLabel(jump, jump.getTargetLabel(target), getBreakTargetTypes(target));
   19.44          doesNotContinueSequentially();
   19.45          return false;
   19.46      }
   19.47 @@ -703,18 +684,9 @@
   19.48      }
   19.49  
   19.50      @Override
   19.51 -    public boolean enterSplitNode(final SplitNode splitNode) {
   19.52 -        if(!reachable) {
   19.53 -            return false;
   19.54 -        }
   19.55 -        // Need to visit inside of split nodes. While it's true that they don't have local variables, we need to visit
   19.56 -        // breaks, continues, and returns in them.
   19.57 -        if(topSplit == null) {
   19.58 -            topSplit = splitNode;
   19.59 -        }
   19.60 -        split = true;
   19.61 -        setType(getCompilerConstantSymbol(lc.getCurrentFunction(), CompilerConstants.RETURN), LvarType.UNDEFINED);
   19.62 -        return true;
   19.63 +    public boolean enterSplitReturn(final SplitReturn splitReturn) {
   19.64 +        doesNotContinueSequentially();
   19.65 +        return false;
   19.66      }
   19.67  
   19.68      @Override
   19.69 @@ -1116,15 +1088,6 @@
   19.70          if(returnType.isUnknown()) {
   19.71              returnType = Type.OBJECT;
   19.72          }
   19.73 -
   19.74 -        if(split) {
   19.75 -            // If the function is split, the ":return" symbol is used and needs a slot. Note we can't mark the return
   19.76 -            // symbol as used in enterSplitNode, as we don't know the final return type of the function earlier than
   19.77 -            // here.
   19.78 -            final Symbol retSymbol = getCompilerConstantSymbol(lc.getCurrentFunction(), CompilerConstants.RETURN);
   19.79 -            retSymbol.setHasSlotFor(returnType);
   19.80 -            retSymbol.setNeedsSlot(true);
   19.81 -        }
   19.82      }
   19.83  
   19.84      private void createSyntheticReturn(final Block body) {

    20.1 --- a/src/jdk/nashorn/internal/codegen/Lower.java	Mon Oct 27 14:36:13 2014 -0700
    20.2 +++ b/src/jdk/nashorn/internal/codegen/Lower.java	Thu Nov 06 09:50:15 2014 -0800
    20.3 @@ -352,8 +352,6 @@
    20.4      private Node spliceFinally(final TryNode tryNode, final List<ThrowNode> rethrows, final Block finallyBody) {
    20.5          assert tryNode.getFinallyBody() == null;
    20.6  
    20.7 -        final LexicalContext lowerLc = lc;
    20.8 -
    20.9          final TryNode newTryNode = (TryNode)tryNode.accept(new NodeVisitor<LexicalContext>(new LexicalContext()) {
   20.10              final List<Node> insideTry = new ArrayList<>();
   20.11  
   20.12 @@ -406,7 +404,6 @@
   20.13                      //still in the try block, store it in a result value and return it afterwards
   20.14                      resultNode = new IdentNode(Lower.this.compilerConstant(RETURN));
   20.15                      newStatements.add(new ExpressionStatement(returnNode.getLineNumber(), returnNode.getToken(), returnNode.getFinish(), new BinaryNode(Token.recast(returnNode.getToken(), TokenType.ASSIGN), resultNode, expr)));
   20.16 -                    lowerLc.setFlag(lowerLc.getCurrentFunction(), FunctionNode.USES_RETURN_SYMBOL);
   20.17                  } else {
   20.18                      resultNode = null;
   20.19                  }

    21.1 --- a/src/jdk/nashorn/internal/codegen/MethodEmitter.java	Mon Oct 27 14:36:13 2014 -0700
    21.2 +++ b/src/jdk/nashorn/internal/codegen/MethodEmitter.java	Thu Nov 06 09:50:15 2014 -0800
    21.3 @@ -71,6 +71,7 @@
    21.4  import static jdk.nashorn.internal.codegen.ObjectClassGenerator.PRIMITIVE_FIELD_TYPE;
    21.5  import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_OPTIMISTIC;
    21.6  import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.CALLSITE_PROGRAM_POINT_SHIFT;
    21.7 +
    21.8  import java.io.PrintStream;
    21.9  import java.lang.reflect.Array;
   21.10  import java.util.Collection;
   21.11 @@ -88,17 +89,16 @@
   21.12  import jdk.nashorn.internal.codegen.types.BitwiseType;
   21.13  import jdk.nashorn.internal.codegen.types.NumericType;
   21.14  import jdk.nashorn.internal.codegen.types.Type;
   21.15 -import jdk.nashorn.internal.ir.BreakableNode;
   21.16  import jdk.nashorn.internal.ir.FunctionNode;
   21.17  import jdk.nashorn.internal.ir.IdentNode;
   21.18  import jdk.nashorn.internal.ir.JoinPredecessor;
   21.19 -import jdk.nashorn.internal.ir.LexicalContext;
   21.20  import jdk.nashorn.internal.ir.LiteralNode;
   21.21  import jdk.nashorn.internal.ir.LocalVariableConversion;
   21.22  import jdk.nashorn.internal.ir.RuntimeNode;
   21.23  import jdk.nashorn.internal.ir.Symbol;
   21.24  import jdk.nashorn.internal.ir.TryNode;
   21.25  import jdk.nashorn.internal.objects.Global;
   21.26 +import jdk.nashorn.internal.objects.NativeArray;
   21.27  import jdk.nashorn.internal.runtime.ArgumentSetter;
   21.28  import jdk.nashorn.internal.runtime.Context;
   21.29  import jdk.nashorn.internal.runtime.Debug;
   21.30 @@ -1663,19 +1663,6 @@
   21.31      }
   21.32  
   21.33      /**
   21.34 -     * Goto, possibly when splitting is taking place. If
   21.35 -     * a splitNode exists, we need to handle the case that the
   21.36 -     * jump target is another method
   21.37 -     *
   21.38 -     * @param label destination label
   21.39 -     * @param targetNode the node to which the destination label belongs (the label is normally a break or continue
   21.40 -     * label)
   21.41 -     */
   21.42 -    void splitAwareGoto(final LexicalContext lc, final Label label, final BreakableNode targetNode) {
   21.43 -        _goto(label);
   21.44 -    }
   21.45 -
   21.46 -    /**
   21.47       * Perform a comparison of two number types that are popped from the stack
   21.48       *
   21.49       * @param isCmpG is this a dcmpg semantic, false if it's a dcmpl semantic
   21.50 @@ -2126,7 +2113,14 @@
   21.51  
   21.52          int pos = 0;
   21.53          for (int i = argCount - 1; i >= 0; i--) {
   21.54 -            paramTypes[i] = stack.peek(pos++);
   21.55 +            Type pt = stack.peek(pos++);
   21.56 +            // "erase" specific ScriptObject subtype info - except for NativeArray.
   21.57 +            // NativeArray is used for array/List/Deque conversion for Java calls.
   21.58 +            if (ScriptObject.class.isAssignableFrom(pt.getTypeClass()) &&
   21.59 +                !NativeArray.class.isAssignableFrom(pt.getTypeClass())) {
   21.60 +                pt = Type.SCRIPT_OBJECT;
   21.61 +            }
   21.62 +            paramTypes[i] = pt;
   21.63          }
   21.64          final String descriptor = Type.getMethodDescriptor(returnType, paramTypes);
   21.65          for (int i = 0; i < argCount; i++) {

    22.1 --- a/src/jdk/nashorn/internal/codegen/OptimisticTypesCalculator.java	Mon Oct 27 14:36:13 2014 -0700
    22.2 +++ b/src/jdk/nashorn/internal/codegen/OptimisticTypesCalculator.java	Thu Nov 06 09:50:15 2014 -0800
    22.3 @@ -30,7 +30,6 @@
    22.4  import java.util.ArrayDeque;
    22.5  import java.util.BitSet;
    22.6  import java.util.Deque;
    22.7 -import jdk.nashorn.internal.IntDeque;
    22.8  import jdk.nashorn.internal.ir.AccessNode;
    22.9  import jdk.nashorn.internal.ir.BinaryNode;
   22.10  import jdk.nashorn.internal.ir.CallNode;
   22.11 @@ -49,7 +48,6 @@
   22.12  import jdk.nashorn.internal.ir.Node;
   22.13  import jdk.nashorn.internal.ir.Optimistic;
   22.14  import jdk.nashorn.internal.ir.PropertyNode;
   22.15 -import jdk.nashorn.internal.ir.SplitNode;
   22.16  import jdk.nashorn.internal.ir.Symbol;
   22.17  import jdk.nashorn.internal.ir.TernaryNode;
   22.18  import jdk.nashorn.internal.ir.UnaryNode;
   22.19 @@ -70,8 +68,6 @@
   22.20  
   22.21      // Per-function bit set of program points that must never be optimistic.
   22.22      final Deque<BitSet> neverOptimistic = new ArrayDeque<>();
   22.23 -    // Per-function depth of split nodes
   22.24 -    final IntDeque splitDepth = new IntDeque();
   22.25  
   22.26      OptimisticTypesCalculator(final Compiler compiler) {
   22.27          super(new LexicalContext());
   22.28 @@ -155,7 +151,6 @@
   22.29              return false;
   22.30          }
   22.31          neverOptimistic.push(new BitSet());
   22.32 -        splitDepth.push(0);
   22.33          return true;
   22.34      }
   22.35  
   22.36 @@ -190,19 +185,6 @@
   22.37      }
   22.38  
   22.39      @Override
   22.40 -    public boolean enterSplitNode(final SplitNode splitNode) {
   22.41 -        splitDepth.getAndIncrement();
   22.42 -        return true;
   22.43 -    }
   22.44 -
   22.45 -    @Override
   22.46 -    public Node leaveSplitNode(final SplitNode splitNode) {
   22.47 -        final int depth = splitDepth.decrementAndGet();
   22.48 -        assert depth >= 0;
   22.49 -        return splitNode;
   22.50 -    }
   22.51 -
   22.52 -    @Override
   22.53      public boolean enterVarNode(final VarNode varNode) {
   22.54          tagNeverOptimistic(varNode.getName());
   22.55          return true;
   22.56 @@ -226,16 +208,11 @@
   22.57      @Override
   22.58      public Node leaveFunctionNode(final FunctionNode functionNode) {
   22.59          neverOptimistic.pop();
   22.60 -        final int lastSplitDepth = splitDepth.pop();
   22.61 -        assert lastSplitDepth == 0;
   22.62          return functionNode.setState(lc, CompilationState.OPTIMISTIC_TYPES_ASSIGNED);
   22.63      }
   22.64  
   22.65      @Override
   22.66      public Node leaveIdentNode(final IdentNode identNode) {
   22.67 -        if(inSplitNode()) {
   22.68 -            return identNode;
   22.69 -        }
   22.70          final Symbol symbol = identNode.getSymbol();
   22.71          if(symbol == null) {
   22.72              assert identNode.isPropertyName();
   22.73 @@ -256,7 +233,7 @@
   22.74  
   22.75      private Expression leaveOptimistic(final Optimistic opt) {
   22.76          final int pp = opt.getProgramPoint();
   22.77 -        if(isValid(pp) && !inSplitNode() && !neverOptimistic.peek().get(pp)) {
   22.78 +        if(isValid(pp) && !neverOptimistic.peek().get(pp)) {
   22.79              return (Expression)opt.setType(compiler.getOptimisticType(opt));
   22.80          }
   22.81          return (Expression)opt;
   22.82 @@ -277,8 +254,4 @@
   22.83              tagNeverOptimistic(test.getExpression());
   22.84          }
   22.85      }
   22.86 -
   22.87 -    private boolean inSplitNode() {
   22.88 -        return splitDepth.peek() > 0;
   22.89 -    }
   22.90  }

    23.1 --- a/src/jdk/nashorn/internal/codegen/ProgramPoints.java	Mon Oct 27 14:36:13 2014 -0700
    23.2 +++ b/src/jdk/nashorn/internal/codegen/ProgramPoints.java	Thu Nov 06 09:50:15 2014 -0800
    23.3 @@ -85,7 +85,7 @@
    23.4  
    23.5      @Override
    23.6      public boolean enterVarNode(final VarNode varNode) {
    23.7 -        noProgramPoint.add(varNode.getAssignmentDest());
    23.8 +        noProgramPoint.add(varNode.getName());
    23.9          return true;
   23.10      }
   23.11  

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/src/jdk/nashorn/internal/codegen/ReplaceCompileUnits.java	Thu Nov 06 09:50:15 2014 -0800
    24.3 @@ -0,0 +1,85 @@
    24.4 +/*
    24.5 + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
    24.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    24.7 + *
    24.8 + * This code is free software; you can redistribute it and/or modify it
    24.9 + * under the terms of the GNU General Public License version 2 only, as
   24.10 + * published by the Free Software Foundation.  Oracle designates this
   24.11 + * particular file as subject to the "Classpath" exception as provided
   24.12 + * by Oracle in the LICENSE file that accompanied this code.
   24.13 + *
   24.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   24.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   24.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   24.17 + * version 2 for more details (a copy is included in the LICENSE file that
   24.18 + * accompanied this code).
   24.19 + *
   24.20 + * You should have received a copy of the GNU General Public License version
   24.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   24.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   24.23 + *
   24.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   24.25 + * or visit www.oracle.com if you need additional information or have any
   24.26 + * questions.
   24.27 + */
   24.28 +
   24.29 +package jdk.nashorn.internal.codegen;
   24.30 +
   24.31 +import java.util.ArrayList;
   24.32 +import java.util.List;
   24.33 +import jdk.nashorn.internal.ir.CompileUnitHolder;
   24.34 +import jdk.nashorn.internal.ir.FunctionNode;
   24.35 +import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
   24.36 +import jdk.nashorn.internal.ir.LexicalContext;
   24.37 +import jdk.nashorn.internal.ir.LiteralNode;
   24.38 +import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode;
   24.39 +import jdk.nashorn.internal.ir.LiteralNode.ArrayLiteralNode.ArrayUnit;
   24.40 +import jdk.nashorn.internal.ir.Node;
   24.41 +import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   24.42 +
   24.43 +/**
   24.44 + * Base class for a node visitor that replaces {@link CompileUnit}s in {@link CompileUnitHolder}s.
   24.45 + */
   24.46 +abstract class ReplaceCompileUnits extends NodeVisitor<LexicalContext> {
   24.47 +    ReplaceCompileUnits() {
   24.48 +        super(new LexicalContext());
   24.49 +    }
   24.50 +
   24.51 +    /**
   24.52 +     * Override to provide a replacement for an old compile unit.
   24.53 +     * @param oldUnit the old compile unit to replace
   24.54 +     * @return the compile unit's replacement.
   24.55 +     */
   24.56 +    abstract CompileUnit getReplacement(final CompileUnit oldUnit);
   24.57 +
   24.58 +    CompileUnit getExistingReplacement(final CompileUnitHolder node) {
   24.59 +        final CompileUnit oldUnit = node.getCompileUnit();
   24.60 +        assert oldUnit != null;
   24.61 +
   24.62 +        final CompileUnit newUnit = getReplacement(oldUnit);
   24.63 +        assert newUnit != null;
   24.64 +
   24.65 +        return newUnit;
   24.66 +    }
   24.67 +
   24.68 +    @Override
   24.69 +    public Node leaveFunctionNode(final FunctionNode node) {
   24.70 +        return node.setCompileUnit(lc, getExistingReplacement(node)).setState(lc, CompilationState.COMPILE_UNITS_REUSED);
   24.71 +    }
   24.72 +
   24.73 +    @Override
   24.74 +    public Node leaveLiteralNode(final LiteralNode<?> node) {
   24.75 +        if (node instanceof ArrayLiteralNode) {
   24.76 +            final ArrayLiteralNode aln = (ArrayLiteralNode)node;
   24.77 +            if (aln.getUnits() == null) {
   24.78 +                return node;
   24.79 +            }
   24.80 +            final List<ArrayUnit> newArrayUnits = new ArrayList<>();
   24.81 +            for (final ArrayUnit au : aln.getUnits()) {
   24.82 +                newArrayUnits.add(new ArrayUnit(getExistingReplacement(au), au.getLo(), au.getHi()));
   24.83 +            }
   24.84 +            return aln.setUnits(lc, newArrayUnits);
   24.85 +        }
   24.86 +        return node;
   24.87 +    }
   24.88 +}

    25.1 --- a/src/jdk/nashorn/internal/codegen/SpillObjectCreator.java	Mon Oct 27 14:36:13 2014 -0700
    25.2 +++ b/src/jdk/nashorn/internal/codegen/SpillObjectCreator.java	Thu Nov 06 09:50:15 2014 -0800
    25.3 @@ -88,7 +88,7 @@
    25.4                      final Property property = propertyMap.findProperty(key);
    25.5                      if (property != null) {
    25.6                          // normal property key
    25.7 -                        property.setCurrentType(JSType.unboxedFieldType(constantValue));
    25.8 +                        property.setType(JSType.unboxedFieldType(constantValue));
    25.9                          final int slot = property.getSlot();
   25.10                          if (!OBJECT_FIELDS_ONLY && constantValue instanceof Number) {
   25.11                              jpresetValues[slot] = ObjectClassGenerator.pack((Number)constantValue);

    26.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    26.2 +++ b/src/jdk/nashorn/internal/codegen/SplitIntoFunctions.java	Thu Nov 06 09:50:15 2014 -0800
    26.3 @@ -0,0 +1,446 @@
    26.4 +/*
    26.5 + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
    26.6 + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    26.7 + *
    26.8 + * This code is free software; you can redistribute it and/or modify it
    26.9 + * under the terms of the GNU General Public License version 2 only, as
   26.10 + * published by the Free Software Foundation.  Oracle designates this
   26.11 + * particular file as subject to the "Classpath" exception as provided
   26.12 + * by Oracle in the LICENSE file that accompanied this code.
   26.13 + *
   26.14 + * This code is distributed in the hope that it will be useful, but WITHOUT
   26.15 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   26.16 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   26.17 + * version 2 for more details (a copy is included in the LICENSE file that
   26.18 + * accompanied this code).
   26.19 + *
   26.20 + * You should have received a copy of the GNU General Public License version
   26.21 + * 2 along with this work; if not, write to the Free Software Foundation,
   26.22 + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   26.23 + *
   26.24 + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   26.25 + * or visit www.oracle.com if you need additional information or have any
   26.26 + * questions.
   26.27 + */
   26.28 +
   26.29 +package jdk.nashorn.internal.codegen;
   26.30 +
   26.31 +import static jdk.nashorn.internal.ir.Node.NO_FINISH;
   26.32 +import static jdk.nashorn.internal.ir.Node.NO_LINE_NUMBER;
   26.33 +import static jdk.nashorn.internal.ir.Node.NO_TOKEN;
   26.34 +
   26.35 +import java.util.ArrayDeque;
   26.36 +import java.util.ArrayList;
   26.37 +import java.util.Arrays;
   26.38 +import java.util.Collections;
   26.39 +import java.util.Deque;
   26.40 +import java.util.List;
   26.41 +import java.util.Objects;
   26.42 +import jdk.nashorn.internal.ir.AccessNode;
   26.43 +import jdk.nashorn.internal.ir.BinaryNode;
   26.44 +import jdk.nashorn.internal.ir.Block;
   26.45 +import jdk.nashorn.internal.ir.BlockLexicalContext;
   26.46 +import jdk.nashorn.internal.ir.BreakNode;
   26.47 +import jdk.nashorn.internal.ir.CallNode;
   26.48 +import jdk.nashorn.internal.ir.CaseNode;
   26.49 +import jdk.nashorn.internal.ir.ContinueNode;
   26.50 +import jdk.nashorn.internal.ir.Expression;
   26.51 +import jdk.nashorn.internal.ir.ExpressionStatement;
   26.52 +import jdk.nashorn.internal.ir.FunctionNode;
   26.53 +import jdk.nashorn.internal.ir.GetSplitState;
   26.54 +import jdk.nashorn.internal.ir.IdentNode;
   26.55 +import jdk.nashorn.internal.ir.IfNode;
   26.56 +import jdk.nashorn.internal.ir.JumpStatement;
   26.57 +import jdk.nashorn.internal.ir.LiteralNode;
   26.58 +import jdk.nashorn.internal.ir.Node;
   26.59 +import jdk.nashorn.internal.ir.ReturnNode;
   26.60 +import jdk.nashorn.internal.ir.SetSplitState;
   26.61 +import jdk.nashorn.internal.ir.SplitNode;
   26.62 +import jdk.nashorn.internal.ir.SplitReturn;
   26.63 +import jdk.nashorn.internal.ir.Statement;
   26.64 +import jdk.nashorn.internal.ir.SwitchNode;
   26.65 +import jdk.nashorn.internal.ir.VarNode;
   26.66 +import jdk.nashorn.internal.ir.visitor.NodeVisitor;
   26.67 +import jdk.nashorn.internal.parser.Token;
   26.68 +import jdk.nashorn.internal.parser.TokenType;
   26.69 +
   26.70 +/**
   26.71 + * A node visitor that replaces {@link SplitNode}s with anonymous function invocations and some additional constructs
   26.72 + * to support control flow across splits. By using this transformation, split functions are translated into ordinary
   26.73 + * JavaScript functions with nested anonymous functions. The transformations however introduce several AST nodes that
   26.74 + * have no JavaScript source representations ({@link GetSplitState}, {@link SetSplitState}, and {@link SplitReturn}),
   26.75 + * and therefore such function is no longer reparseable from its source. For that reason, split functions and their
   26.76 + * fragments are serialized in-memory and deserialized when they need to be recompiled either for deoptimization or
   26.77 + * for type specialization.
   26.78 + * NOTE: all {@code leave*()} methods for statements are returning their input nodes. That way, they will not mutate
   26.79 + * the original statement list in the block containing the statement, which is fine, as it'll be replaced by the
   26.80 + * lexical context when the block is left. If we returned something else (e.g. null), we'd cause a mutation in the
   26.81 + * enclosing block's statement list that is otherwise overwritten later anyway.
   26.82 + */
   26.83 +final class SplitIntoFunctions extends NodeVisitor<BlockLexicalContext> {
   26.84 +    private static final int FALLTHROUGH_STATE = -1;
   26.85 +    private static final int RETURN_STATE = 0;
   26.86 +    private static final int BREAK_STATE = 1;
   26.87 +    private static final int FIRST_JUMP_STATE = 2;
   26.88 +
   26.89 +    private static final String THIS_NAME = CompilerConstants.THIS.symbolName();
   26.90 +    private static final String RETURN_NAME = CompilerConstants.RETURN.symbolName();
   26.91 +    // Used as the name of the formal parameter for passing the current value of :return symbol into a split fragment.
   26.92 +    private static final String RETURN_PARAM_NAME = RETURN_NAME + "-in";
   26.93 +
   26.94 +    private final Deque<FunctionState> functionStates = new ArrayDeque<>();
   26.95 +    private final Deque<SplitState> splitStates = new ArrayDeque<>();
   26.96 +    private final Namespace namespace;
   26.97 +
   26.98 +    private boolean artificialBlock = false;
   26.99 +
  26.100 +    // -1 is program; we need to use negative ones
  26.101 +    private int nextFunctionId = -2;
  26.102 +
  26.103 +    public SplitIntoFunctions(final Compiler compiler) {
  26.104 +        super(new BlockLexicalContext() {
  26.105 +            @Override
  26.106 +            protected Block afterSetStatements(Block block) {
  26.107 +                for(Statement stmt: block.getStatements()) {
  26.108 +                    assert !(stmt instanceof SplitNode);
  26.109 +                }
  26.110 +                return block;
  26.111 +            }
  26.112 +        });
  26.113 +        namespace = new Namespace(compiler.getScriptEnvironment().getNamespace());
  26.114 +    }
  26.115 +
  26.116 +    @Override
  26.117 +    public boolean enterFunctionNode(final FunctionNode functionNode) {
  26.118 +        functionStates.push(new FunctionState(functionNode));
  26.119 +        return true;
  26.120 +    }
  26.121 +
  26.122 +    @Override
  26.123 +    public Node leaveFunctionNode(final FunctionNode functionNode) {
  26.124 +        functionStates.pop();
  26.125 +        return functionNode;
  26.126 +    }
  26.127 +
  26.128 +    @Override
  26.129 +    protected Node leaveDefault(final Node node) {
  26.130 +        if (node instanceof Statement) {
  26.131 +            appendStatement((Statement)node);
  26.132 +        }
  26.133 +        return node;
  26.134 +    }
  26.135 +
  26.136 +    @Override
  26.137 +    public boolean enterSplitNode(final SplitNode splitNode) {
  26.138 +        getCurrentFunctionState().splitDepth++;
  26.139 +        splitStates.push(new SplitState(splitNode));
  26.140 +        return true;
  26.141 +    }
  26.142 +
  26.143 +    @Override
  26.144 +    public Node leaveSplitNode(final SplitNode splitNode) {
  26.145 +        // Replace the split node with an anonymous function expression call.
  26.146 +
  26.147 +        final FunctionState fnState = getCurrentFunctionState();
  26.148 +
  26.149 +        final String name = splitNode.getName();
  26.150 +        Block body = splitNode.getBody();
  26.151 +        final int firstLineNumber = body.getFirstStatementLineNumber();
  26.152 +        final long token = body.getToken();
  26.153 +        final int finish = body.getFinish();
  26.154 +
  26.155 +        final FunctionNode originalFn = fnState.fn;
  26.156 +        assert originalFn == lc.getCurrentFunction();
  26.157 +        final boolean isProgram = originalFn.isProgram();
  26.158 +
  26.159 +        // Change SplitNode({...}) into "function () { ... }", or "function (:return-in) () { ... }" (for program)
  26.160 +        final long newFnToken = Token.toDesc(TokenType.FUNCTION, nextFunctionId--, 0);
  26.161 +        final FunctionNode fn = new FunctionNode(
  26.162 +                originalFn.getSource(),
  26.163 +                body.getFirstStatementLineNumber(),
  26.164 +                newFnToken,
  26.165 +                finish,
  26.166 +                NO_TOKEN,
  26.167 +                namespace,
  26.168 +                createIdent(name),
  26.169 +                originalFn.getName() + "$" + name,
  26.170 +                isProgram ? Collections.singletonList(createReturnParamIdent()) : Collections.<IdentNode>emptyList(),
  26.171 +                FunctionNode.Kind.NORMAL,
  26.172 +                // We only need IS_SPLIT conservatively, in case it contains any array units so that we force
  26.173 +                // the :callee's existence, to force :scope to never be in a slot lower than 2. This is actually
  26.174 +                // quite a horrible hack to do with CodeGenerator.fixScopeSlot not trampling other parameters
  26.175 +                // and should go away once we no longer have array unit handling in codegen. Note however that
  26.176 +                // we still use IS_SPLIT as the criteria in CompilationPhase.SERIALIZE_SPLIT_PHASE.
  26.177 +                FunctionNode.IS_ANONYMOUS | FunctionNode.USES_ANCESTOR_SCOPE | FunctionNode.IS_SPLIT
  26.178 +        )
  26.179 +        .setBody(lc, body)
  26.180 +        .setCompileUnit(lc, splitNode.getCompileUnit())
  26.181 +        .copyCompilationState(lc, originalFn);
  26.182 +
  26.183 +        // Call the function:
  26.184 +        //     either "(function () { ... }).call(this)"
  26.185 +        //     or     "(function (:return-in) { ... }).call(this, :return)"
  26.186 +        // NOTE: Function.call() has optimized linking that basically does a pass-through to the function being invoked.
  26.187 +        // NOTE: CompilationPhase.PROGRAM_POINT_PHASE happens after this, so these calls are subject to optimistic
  26.188 +        // assumptions on their return value (when they return a value), as they should be.
  26.189 +        final IdentNode thisIdent = createIdent(THIS_NAME);
  26.190 +        final CallNode callNode = new CallNode(firstLineNumber, token, finish, new AccessNode(NO_TOKEN, NO_FINISH, fn, "call"),
  26.191 +                isProgram ? Arrays.<Expression>asList(thisIdent, createReturnIdent())
  26.192 +                          : Collections.<Expression>singletonList(thisIdent),
  26.193 +                false);
  26.194 +
  26.195 +        final SplitState splitState = splitStates.pop();
  26.196 +        fnState.splitDepth--;
  26.197 +
  26.198 +        final Expression callWithReturn;
  26.199 +        final boolean hasReturn = splitState.hasReturn;
  26.200 +        if (hasReturn && fnState.splitDepth > 0) {
  26.201 +            final SplitState parentSplit = splitStates.peek();
  26.202 +            if (parentSplit != null) {
  26.203 +                // Propagate hasReturn to parent split
  26.204 +                parentSplit.hasReturn = true;
  26.205 +            }
  26.206 +        }
  26.207 +        if (hasReturn || isProgram) {
  26.208 +            // capture return value: ":return = (function () { ... })();"
  26.209 +            callWithReturn = new BinaryNode(Token.recast(token, TokenType.ASSIGN), createReturnIdent(), callNode);
  26.210 +        } else {
  26.211 +            // no return value, just call : "(function () { ... })();"
  26.212 +            callWithReturn = callNode;
  26.213 +        }
  26.214 +        appendStatement(new ExpressionStatement(firstLineNumber, token, finish, callWithReturn));
  26.215 +
  26.216 +        Statement splitStateHandler;
  26.217 +
  26.218 +        final List<JumpStatement> jumpStatements = splitState.jumpStatements;
  26.219 +        final int jumpCount = jumpStatements.size();
  26.220 +        // There are jumps (breaks or continues) that need to be propagated outside the split node. We need to
  26.221 +        // set up a switch statement for them:
  26.222 +        // switch(:scope.getScopeState()) { ... }
  26.223 +        if (jumpCount > 0) {
  26.224 +            final List<CaseNode> cases = new ArrayList<>(jumpCount + (hasReturn ? 1 : 0));
  26.225 +            if (hasReturn) {
  26.226 +                // If the split node also contained a return, we'll slip it as a case in the switch statement
  26.227 +                addCase(cases, RETURN_STATE, createReturnFromSplit());
  26.228 +            }
  26.229 +            int i = FIRST_JUMP_STATE;
  26.230 +            for (final JumpStatement jump: jumpStatements) {
  26.231 +                addCase(cases, i++, enblockAndVisit(jump));
  26.232 +            }
  26.233 +            splitStateHandler = new SwitchNode(NO_LINE_NUMBER, token, finish, GetSplitState.INSTANCE, cases, null);
  26.234 +        } else {
  26.235 +            splitStateHandler = null;
  26.236 +        }
  26.237 +
  26.238 +        // As the switch statement itself is breakable, an unlabelled break can't be in the switch statement,
  26.239 +        // so we need to test for it separately.
  26.240 +        if (splitState.hasBreak) {
  26.241 +            // if(:scope.getScopeState() == Scope.BREAK) { break; }
  26.242 +            splitStateHandler = makeIfStateEquals(firstLineNumber, token, finish, BREAK_STATE,
  26.243 +                    enblockAndVisit(new BreakNode(NO_LINE_NUMBER, token, finish, null)), splitStateHandler);
  26.244 +        }
  26.245 +
  26.246 +        // Finally, if the split node had a return statement, but there were no external jumps, we didn't have
  26.247 +        // the switch statement to handle the return, so we need a separate if for it.
  26.248 +        if (hasReturn && jumpCount == 0) {
  26.249 +            // if (:scope.getScopeState() == Scope.RETURN) { return :return; }
  26.250 +            splitStateHandler = makeIfStateEquals(NO_LINE_NUMBER, token, finish, RETURN_STATE,
  26.251 +                    createReturnFromSplit(), splitStateHandler);
  26.252 +        }
  26.253 +
  26.254 +        if (splitStateHandler != null) {
  26.255 +            appendStatement(splitStateHandler);
  26.256 +        }
  26.257 +
  26.258 +        return splitNode;
  26.259 +    }
  26.260 +
  26.261 +    private static void addCase(final List<CaseNode> cases, final int i, final Block body) {
  26.262 +        cases.add(new CaseNode(NO_TOKEN, NO_FINISH, intLiteral(i), body));
  26.263 +    }
  26.264 +
  26.265 +    private static LiteralNode<Number> intLiteral(final int i) {
  26.266 +        return LiteralNode.newInstance(NO_TOKEN, NO_FINISH, i);
  26.267 +    }
  26.268 +
  26.269 +    private static Block createReturnFromSplit() {
  26.270 +        return new Block(NO_TOKEN, NO_FINISH, createReturnReturn());
  26.271 +    }
  26.272 +
  26.273 +    private static ReturnNode createReturnReturn() {
  26.274 +        return new ReturnNode(NO_LINE_NUMBER, NO_TOKEN, NO_FINISH, createReturnIdent());
  26.275 +    }
  26.276 +
  26.277 +    private static IdentNode createReturnIdent() {
  26.278 +        return createIdent(RETURN_NAME);
  26.279 +    }
  26.280 +
  26.281 +    private static IdentNode createReturnParamIdent() {
  26.282 +        return createIdent(RETURN_PARAM_NAME);
  26.283 +    }
  26.284 +
  26.285 +    private static IdentNode createIdent(final String name) {
  26.286 +        return new IdentNode(NO_TOKEN, NO_FINISH, name);
  26.287 +    }
  26.288 +
  26.289 +    private Block enblockAndVisit(final JumpStatement jump) {
  26.290 +        artificialBlock = true;
  26.291 +        final Block block = (Block)new Block(NO_TOKEN, NO_FINISH, jump).accept(this);
  26.292 +        artificialBlock = false;
  26.293 +        return block;
  26.294 +    }
  26.295 +
  26.296 +    private static IfNode makeIfStateEquals(final int lineNumber, final long token, final int finish,
  26.297 +            final int value, final Block pass, final Statement fail) {
  26.298 +        return new IfNode(lineNumber, token, finish,
  26.299 +                new BinaryNode(Token.recast(token, TokenType.EQ_STRICT),
  26.300 +                        GetSplitState.INSTANCE, intLiteral(value)),
  26.301 +                pass,
  26.302 +                fail == null ? null : new Block(NO_TOKEN, NO_FINISH, fail));
  26.303 +    }
  26.304 +
  26.305 +    @Override
  26.306 +    public boolean enterVarNode(VarNode varNode) {
  26.307 +        if (!inSplitNode()) {
  26.308 +            return super.enterVarNode(varNode);
  26.309 +        }
  26.310 +        assert !varNode.isBlockScoped(); //TODO: we must handle these too, but we currently don't
  26.311 +
  26.312 +        final Expression init = varNode.getInit();
  26.313 +        if (varNode.isAnonymousFunctionDeclaration()) {
  26.314 +            // We ain't moving anonymous function declarations.
  26.315 +            return super.enterVarNode(varNode);
  26.316 +        }
  26.317 +
  26.318 +        // Move a declaration-only var statement to the top of the outermost function.
  26.319 +        getCurrentFunctionState().varStatements.add(varNode.setInit(null));
  26.320 +        // If it had an initializer, replace it with an assignment expression statement. Note that "var" is a
  26.321 +        // statement, so it doesn't contribute to :return of the programs, therefore we are _not_ adding a
  26.322 +        // ":return = ..." assignment around the original assignment.
  26.323 +        if (init != null) {
  26.324 +            final long token = Token.recast(varNode.getToken(), TokenType.ASSIGN);
  26.325 +            new ExpressionStatement(varNode.getLineNumber(), token, varNode.getFinish(),
  26.326 +                    new BinaryNode(token, varNode.getName(), varNode.getInit())).accept(this);
  26.327 +        }
  26.328 +
  26.329 +        return false;
  26.330 +    }
  26.331 +
  26.332 +    @Override
  26.333 +    public Node leaveBlock(final Block block) {
  26.334 +        if (!artificialBlock) {
  26.335 +            if (lc.isFunctionBody()) {
  26.336 +                // Prepend declaration-only var statements to the top of the statement list.
  26.337 +                lc.prependStatements(getCurrentFunctionState().varStatements);
  26.338 +            } else if (lc.isSplitBody()) {
  26.339 +                appendSplitReturn(FALLTHROUGH_STATE, NO_LINE_NUMBER);
  26.340 +                if (getCurrentFunctionState().fn.isProgram()) {
  26.341 +                    // If we're splitting the program, make sure every shard ends with "return :return" and
  26.342 +                    // begins with ":return = :return-in;".
  26.343 +                    lc.prependStatement(new ExpressionStatement(NO_LINE_NUMBER, NO_TOKEN, NO_FINISH,
  26.344 +                            new BinaryNode(Token.toDesc(TokenType.ASSIGN, 0, 0), createReturnIdent(), createReturnParamIdent())));
  26.345 +                }
  26.346 +            }
  26.347 +        }
  26.348 +        return block;
  26.349 +    }
  26.350 +
  26.351 +    @Override
  26.352 +    public Node leaveBreakNode(final BreakNode breakNode) {
  26.353 +        return leaveJumpNode(breakNode);
  26.354 +    }
  26.355 +
  26.356 +    @Override
  26.357 +    public Node leaveContinueNode(final ContinueNode continueNode) {
  26.358 +        return leaveJumpNode(continueNode);
  26.359 +    }
  26.360 +
  26.361 +    private JumpStatement leaveJumpNode(final JumpStatement jump) {
  26.362 +        if (inSplitNode()) {
  26.363 +            final SplitState splitState = getCurrentSplitState();
  26.364 +            final SplitNode splitNode = splitState.splitNode;
  26.365 +            if (lc.isExternalTarget(splitNode, jump.getTarget(lc))) {
  26.366 +                appendSplitReturn(splitState.getSplitStateIndex(jump), jump.getLineNumber());
  26.367 +                return jump;
  26.368 +            }
  26.369 +        }
  26.370 +        appendStatement(jump);
  26.371 +        return jump;
  26.372 +    }
  26.373 +
  26.374 +    private void appendSplitReturn(final int splitState, final int lineNumber) {
  26.375 +        appendStatement(new SetSplitState(splitState, lineNumber));
  26.376 +        if (getCurrentFunctionState().fn.isProgram()) {
  26.377 +            // If we're splitting the program, make sure every fragment passes back :return
  26.378 +            appendStatement(createReturnReturn());
  26.379 +        } else {
  26.380 +            appendStatement(SplitReturn.INSTANCE);
  26.381 +        }
  26.382 +    }
  26.383 +
  26.384 +    @Override
  26.385 +    public Node leaveReturnNode(final ReturnNode returnNode) {
  26.386 +        if(inSplitNode()) {
  26.387 +            appendStatement(new SetSplitState(RETURN_STATE, returnNode.getLineNumber()));
  26.388 +            getCurrentSplitState().hasReturn = true;
  26.389 +        }
  26.390 +        appendStatement(returnNode);
  26.391 +        return returnNode;
  26.392 +    }
  26.393 +
  26.394 +    private void appendStatement(final Statement statement) {
  26.395 +        lc.appendStatement(statement);
  26.396 +    }
  26.397 +
  26.398 +    private boolean inSplitNode() {
  26.399 +        return getCurrentFunctionState().splitDepth > 0;
  26.400 +    }
  26.401 +
  26.402 +    private FunctionState getCurrentFunctionState() {
  26.403 +        return functionStates.peek();
  26.404 +    }
  26.405 +
  26.406 +    private SplitState getCurrentSplitState() {
  26.407 +        return splitStates.peek();
  26.408 +    }
  26.409 +
  26.410 +    private static class FunctionState {
  26.411 +        final FunctionNode fn;
  26.412 +        final List<Statement> varStatements = new ArrayList<>();
  26.413 +        int splitDepth;
  26.414 +
  26.415 +        FunctionState(final FunctionNode fn) {
  26.416 +            this.fn = fn;
  26.417 +        }
  26.418 +    }
  26.419 +
  26.420 +    private static class SplitState {
  26.421 +        final SplitNode splitNode;
  26.422 +        boolean hasReturn;
  26.423 +        boolean hasBreak;
  26.424 +
  26.425 +        final List<JumpStatement> jumpStatements = new ArrayList<>();
  26.426 +
  26.427 +        int getSplitStateIndex(final JumpStatement jump) {
  26.428 +            if (jump instanceof BreakNode && jump.getLabelName() == null) {
  26.429 +                // Unlabelled break is a special case
  26.430 +                hasBreak = true;
  26.431 +                return BREAK_STATE;
  26.432 +            }
  26.433 +
  26.434 +            int i = 0;
  26.435 +            for(final JumpStatement exJump: jumpStatements) {
  26.436 +                if (jump.getClass() == exJump.getClass() && Objects.equals(jump.getLabelName(), exJump.getLabelName())) {
  26.437 +                    return i + FIRST_JUMP_STATE;
  26.438 +                }
  26.439 +                ++i;
  26.440 +            }
  26.441 +            jumpStatements.add(jump);
  26.442 +            return i + FIRST_JUMP_STATE;
  26.443 +        }
  26.444 +
  26.445 +        SplitState(final SplitNode splitNode) {
  26.446 +            this.splitNode = splitNode;
  26.447 +        }
  26.448 +    }
  26.449 +}

    27.1 --- a/src/jdk/nashorn/internal/codegen/SplitMethodEmitter.java	Mon Oct 27 14:36:13 2014 -0700
    27.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
    27.3 @@ -1,102 +0,0 @@
    27.4 -/*
    27.5 - * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
    27.6 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    27.7 - *
    27.8 - * This code is free software; you can redistribute it and/or modify it
    27.9 - * under the terms of the GNU General Public License version 2 only, as
   27.10 - * published by the Free Software Foundation.  Oracle designates this
   27.11 - * particular file as subject to the "Classpath" exception as provided
   27.12 - * by Oracle in the LICENSE file that accompanied this code.
   27.13 - *
   27.14 - * This code is distributed in the hope that it will be useful, but WITHOUT
   27.15 - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   27.16 - * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   27.17 - * version 2 for more details (a copy is included in the LICENSE file that
   27.18 - * accompanied this code).
   27.19 - *
   27.20 - * You should have received a copy of the GNU General Public License version
   27.21 - * 2 along with this work; if not, write to the Free Software Foundation,
   27.22 - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   27.23 - *
   27.24 - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   27.25 - * or visit www.oracle.com if you need additional information or have any
   27.26 - * questions.
   27.27 - */
   27.28 -
   27.29 -package jdk.nashorn.internal.codegen;
   27.30 -
   27.31 -import java.util.ArrayList;
   27.32 -import java.util.List;
   27.33 -import jdk.internal.org.objectweb.asm.MethodVisitor;
   27.34 -import jdk.nashorn.internal.codegen.types.Type;
   27.35 -import jdk.nashorn.internal.ir.BreakableNode;
   27.36 -import jdk.nashorn.internal.ir.LexicalContext;
   27.37 -import jdk.nashorn.internal.ir.SplitNode;
   27.38 -
   27.39 -/**
   27.40 - * Emitter used for splitting methods. Needs to keep track of if there are jump targets
   27.41 - * outside the current split node. All external jump targets encountered at method
   27.42 - * emission are logged, and {@code CodeGenerator#leaveSplitNode(SplitNode)} creates
   27.43 - * an appropriate jump table when the SplitNode has been iterated through
   27.44 - */
   27.45 -public class SplitMethodEmitter extends MethodEmitter {
   27.46 -
   27.47 -    private final SplitNode splitNode;
   27.48 -
   27.49 -    private final List<Label> externalTargets = new ArrayList<>();
   27.50 -    /**
   27.51 -     * In addition to external target labels, we need to track the target breakables too as the code generator needs to
   27.52 -     * be able to correctly pop the scopes to the target, see {@link CodeGenerator#leaveSplitNode(SplitNode)}. Note that
   27.53 -     * this is only used within CodeGenerator, which doesn't mutate the AST, so keeping pointers to other nodes is not
   27.54 -     * incorrect.
   27.55 -     */
   27.56 -    private final List<BreakableNode> externalTargetNodes = new ArrayList<>();
   27.57 -
   27.58 -    SplitMethodEmitter(final ClassEmitter classEmitter, final MethodVisitor mv, final SplitNode splitNode) {
   27.59 -        super(classEmitter, mv);
   27.60 -        this.splitNode = splitNode;
   27.61 -    }
   27.62 -
   27.63 -    @Override
   27.64 -    void splitAwareGoto(final LexicalContext lc, final Label label, final BreakableNode targetNode) {
   27.65 -        assert splitNode != null;
   27.66 -        final int index = findExternalTarget(lc, label, targetNode);
   27.67 -        if (index >= 0) {
   27.68 -            setSplitState(index + 1); // 0 is ordinary return
   27.69 -            final Type retType = functionNode.getReturnType();
   27.70 -            loadUndefined(retType);
   27.71 -            _return(retType);
   27.72 -        } else {
   27.73 -            super.splitAwareGoto(lc, label, targetNode);
   27.74 -        }
   27.75 -    }
   27.76 -
   27.77 -    private int findExternalTarget(final LexicalContext lc, final Label label, final BreakableNode targetNode) {
   27.78 -        final int index = externalTargets.indexOf(label);
   27.79 -
   27.80 -        if (index >= 0) {
   27.81 -            return index;
   27.82 -        }
   27.83 -
   27.84 -        if (lc.isExternalTarget(splitNode, targetNode)) {
   27.85 -            externalTargets.add(label);
   27.86 -            externalTargetNodes.add(targetNode);
   27.87 -            return externalTargets.size() - 1;
   27.88 -        }
   27.89 -        return -1;
   27.90 -    }
   27.91 -
   27.92 -    @Override
   27.93 -    MethodEmitter registerReturn() {
   27.94 -        setHasReturn();
   27.95 -        return setSplitState(0);
   27.96 -    }
   27.97 -
   27.98 -    final List<Label> getExternalTargets() {
   27.99 -        return externalTargets;
  27.100 -    }
  27.101 -
  27.102 -    final List<BreakableNode> getExternalTargetNodes() {
  27.103 -        return externalTargetNodes;
  27.104 -    }
  27.105 -}

    28.1 --- a/src/jdk/nashorn/internal/codegen/TypeEvaluator.java	Mon Oct 27 14:36:13 2014 -0700
    28.2 +++ b/src/jdk/nashorn/internal/codegen/TypeEvaluator.java	Thu Nov 06 09:50:15 2014 -0800
    28.3 @@ -29,16 +29,22 @@
    28.4  import static jdk.nashorn.internal.runtime.Property.NOT_ENUMERABLE;
    28.5  import static jdk.nashorn.internal.runtime.Property.NOT_WRITABLE;
    28.6  
    28.7 +import java.lang.invoke.MethodType;
    28.8  import jdk.nashorn.internal.codegen.types.Type;
    28.9  import jdk.nashorn.internal.ir.AccessNode;
   28.10 +import jdk.nashorn.internal.ir.CallNode;
   28.11  import jdk.nashorn.internal.ir.Expression;
   28.12 +import jdk.nashorn.internal.ir.FunctionNode;
   28.13  import jdk.nashorn.internal.ir.IdentNode;
   28.14  import jdk.nashorn.internal.ir.IndexNode;
   28.15  import jdk.nashorn.internal.ir.Optimistic;
   28.16 +import jdk.nashorn.internal.objects.ArrayBufferView;
   28.17  import jdk.nashorn.internal.objects.NativeArray;
   28.18  import jdk.nashorn.internal.runtime.FindProperty;
   28.19  import jdk.nashorn.internal.runtime.JSType;
   28.20  import jdk.nashorn.internal.runtime.Property;
   28.21 +import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData;
   28.22 +import jdk.nashorn.internal.runtime.ScriptFunction;
   28.23  import jdk.nashorn.internal.runtime.ScriptObject;
   28.24  import jdk.nashorn.internal.runtime.ScriptRuntime;
   28.25  
   28.26 @@ -47,6 +53,13 @@
   28.27   * Used during recompilation.
   28.28   */
   28.29  final class TypeEvaluator {
   28.30 +    /**
   28.31 +     * Type signature for invocation of functions without parameters: we must pass (callee, this) of type
   28.32 +     * (ScriptFunction, Object) respectively. We also use Object as the return type (we must pass something,
   28.33 +     * but it'll be ignored; it can't be void, though).
   28.34 +     */
   28.35 +    private static final MethodType EMPTY_INVOCATION_TYPE = MethodType.methodType(Object.class, ScriptFunction.class, Object.class);
   28.36 +
   28.37      private final Compiler compiler;
   28.38      private final ScriptObject runtimeScope;
   28.39  
   28.40 @@ -104,7 +117,7 @@
   28.41          }
   28.42  
   28.43          final Property property      = find.getProperty();
   28.44 -        final Class<?> propertyClass = property.getCurrentType();
   28.45 +        final Class<?> propertyClass = property.getType();
   28.46          if (propertyClass == null) {
   28.47              // propertyClass == null means its value is Undefined. It is probably not initialized yet, so we won't make
   28.48              // a type assumption yet.
   28.49 @@ -190,30 +203,46 @@
   28.50                  return null;
   28.51              }
   28.52              return getPropertyType(runtimeScope, ((IdentNode)expr).getName());
   28.53 -        }
   28.54 -
   28.55 -        if (expr instanceof AccessNode) {
   28.56 +        } else if (expr instanceof AccessNode) {
   28.57              final AccessNode accessNode = (AccessNode)expr;
   28.58              final Object base = evaluateSafely(accessNode.getBase());
   28.59              if (!(base instanceof ScriptObject)) {
   28.60                  return null;
   28.61              }
   28.62              return getPropertyType((ScriptObject)base, accessNode.getProperty());
   28.63 -        }
   28.64 -
   28.65 -        if (expr instanceof IndexNode) {
   28.66 +        } else if (expr instanceof IndexNode) {
   28.67              final IndexNode indexNode = (IndexNode)expr;
   28.68              final Object    base = evaluateSafely(indexNode.getBase());
   28.69 -            if(!(base instanceof NativeArray)) {
   28.70 -                // We only know how to deal with NativeArray. TODO: maybe manage buffers too
   28.71 -                return null;
   28.72 +            if(base instanceof NativeArray || base instanceof ArrayBufferView) {
   28.73 +                // NOTE: optimistic array getters throw UnwarrantedOptimismException based on the type of their
   28.74 +                // underlying array storage, not based on values of individual elements. Thus, a LongArrayData will
   28.75 +                // throw UOE for every optimistic int linkage attempt, even if the long value being returned in the
   28.76 +                // first invocation would be representable as int. That way, we can presume that the array's optimistic
   28.77 +                // type is the most optimistic type for which an element getter has a chance of executing successfully.
   28.78 +                return ((ScriptObject)base).getArray().getOptimisticType();
   28.79              }
   28.80 -            // NOTE: optimistic array getters throw UnwarrantedOptimismException based on the type of their underlying
   28.81 -            // array storage, not based on values of individual elements. Thus, a LongArrayData will throw UOE for every
   28.82 -            // optimistic int linkage attempt, even if the long value being returned in the first invocation would be
   28.83 -            // representable as int. That way, we can presume that the array's optimistic type is the most optimistic
   28.84 -            // type for which an element getter has a chance of executing successfully.
   28.85 -            return ((NativeArray)base).getArray().getOptimisticType();
   28.86 +        } else if (expr instanceof CallNode) {
   28.87 +            // Currently, we'll only try to guess the return type of immediately invoked function expressions with no
   28.88 +            // parameters, that is (function() { ... })(). We could do better, but these are all heuristics and we can
   28.89 +            // gradually introduce them as needed. An easy one would be to do the same for .call(this) idiom.
   28.90 +            final CallNode callExpr = (CallNode)expr;
   28.91 +            final Expression fnExpr = callExpr.getFunction();
   28.92 +            if (fnExpr instanceof FunctionNode) {
   28.93 +                final FunctionNode fn = (FunctionNode)fnExpr;
   28.94 +                if (callExpr.getArgs().isEmpty()) {
   28.95 +                    final RecompilableScriptFunctionData data = compiler.getScriptFunctionData(fn.getId());
   28.96 +                    if (data != null) {
   28.97 +                        final Type returnType = Type.typeFor(data.getReturnType(EMPTY_INVOCATION_TYPE, runtimeScope));
   28.98 +                        if (returnType == Type.BOOLEAN) {
   28.99 +                            // We don't have optimistic booleans. In fact, optimistic call sites getting back boolean
  28.100 +                            // currently deoptimize all the way to Object.
  28.101 +                            return Type.OBJECT;
  28.102 +                        }
  28.103 +                        assert returnType == Type.INT || returnType == Type.LONG || returnType == Type.NUMBER || returnType == Type.OBJECT;
  28.104 +                        return returnType;
  28.105 +                    }
  28.106 +                }
  28.107 +            }
  28.108          }
  28.109  
  28.110          return null;

    29.1 --- a/src/jdk/nashorn/internal/codegen/types/ArrayType.java	Mon Oct 27 14:36:13 2014 -0700
    29.2 +++ b/src/jdk/nashorn/internal/codegen/types/ArrayType.java	Thu Nov 06 09:50:15 2014 -0800
    29.3 @@ -37,6 +37,7 @@
    29.4   * This is an array type, i.e. OBJECT_ARRAY, NUMBER_ARRAY.
    29.5   */
    29.6  public class ArrayType extends ObjectType implements BytecodeArrayOps {
    29.7 +    private static final long serialVersionUID = 1L;
    29.8  
    29.9      /**
   29.10       * Constructor

    30.1 --- a/src/jdk/nashorn/internal/codegen/types/BitwiseType.java	Mon Oct 27 14:36:13 2014 -0700
    30.2 +++ b/src/jdk/nashorn/internal/codegen/types/BitwiseType.java	Thu Nov 06 09:50:15 2014 -0800
    30.3 @@ -29,6 +29,7 @@
    30.4   * This class represents a numeric type that can be used for bit operations.
    30.5   */
    30.6  public abstract class BitwiseType extends NumericType implements BytecodeBitwiseOps {
    30.7 +    private static final long serialVersionUID = 1L;
    30.8  
    30.9      /**
   30.10       * Constructor

    31.1 --- a/src/jdk/nashorn/internal/codegen/types/BooleanType.java	Mon Oct 27 14:36:13 2014 -0700
    31.2 +++ b/src/jdk/nashorn/internal/codegen/types/BooleanType.java	Thu Nov 06 09:50:15 2014 -0800
    31.3 @@ -69,6 +69,7 @@
    31.4   * The boolean type class
    31.5   */
    31.6  public final class BooleanType extends Type {
    31.7 +    private static final long serialVersionUID = 1L;
    31.8  
    31.9      private static final CompilerConstants.Call VALUE_OF = staticCallNoLookup(Boolean.class, "valueOf", Boolean.class, boolean.class);
   31.10      private static final CompilerConstants.Call TO_STRING = staticCallNoLookup(Boolean.class, "toString", String.class, boolean.class);

    32.1 --- a/src/jdk/nashorn/internal/codegen/types/IntType.java	Mon Oct 27 14:36:13 2014 -0700
    32.2 +++ b/src/jdk/nashorn/internal/codegen/types/IntType.java	Thu Nov 06 09:50:15 2014 -0800
    32.3 @@ -60,6 +60,7 @@
    32.4   * Type class: INT
    32.5   */
    32.6  class IntType extends BitwiseType {
    32.7 +    private static final long serialVersionUID = 1L;
    32.8  
    32.9      private static final CompilerConstants.Call TO_STRING = staticCallNoLookup(Integer.class, "toString", String.class, int.class);
   32.10      private static final CompilerConstants.Call VALUE_OF  = staticCallNoLookup(Integer.class, "valueOf", Integer.class, int.class);

    33.1 --- a/src/jdk/nashorn/internal/codegen/types/LongType.java	Mon Oct 27 14:36:13 2014 -0700
    33.2 +++ b/src/jdk/nashorn/internal/codegen/types/LongType.java	Thu Nov 06 09:50:15 2014 -0800
    33.3 @@ -54,6 +54,7 @@
    33.4   * Type class: LONG
    33.5   */
    33.6  class LongType extends BitwiseType {
    33.7 +    private static final long serialVersionUID = 1L;
    33.8  
    33.9      private static final CompilerConstants.Call VALUE_OF = staticCallNoLookup(Long.class, "valueOf", Long.class, long.class);
   33.10  

    34.1 --- a/src/jdk/nashorn/internal/codegen/types/NumberType.java	Mon Oct 27 14:36:13 2014 -0700
    34.2 +++ b/src/jdk/nashorn/internal/codegen/types/NumberType.java	Thu Nov 06 09:50:15 2014 -0800
    34.3 @@ -46,6 +46,7 @@
    34.4  import jdk.nashorn.internal.runtime.JSType;
    34.5  
    34.6  class NumberType extends NumericType {
    34.7 +    private static final long serialVersionUID = 1L;
    34.8  
    34.9      private static final CompilerConstants.Call VALUE_OF = staticCallNoLookup(Double.class, "valueOf", Double.class, double.class);
   34.10  

    35.1 --- a/src/jdk/nashorn/internal/codegen/types/NumericType.java	Mon Oct 27 14:36:13 2014 -0700
    35.2 +++ b/src/jdk/nashorn/internal/codegen/types/NumericType.java	Thu Nov 06 09:50:15 2014 -0800
    35.3 @@ -29,6 +29,8 @@
    35.4   * This is a numeric type, i.e. NUMBER, LONG, INT, INT32.
    35.5   */
    35.6  public abstract class NumericType extends Type implements BytecodeNumericOps {
    35.7 +    private static final long serialVersionUID = 1L;
    35.8 +
    35.9      /**
   35.10       * Constructor
   35.11       *

    36.1 --- a/src/jdk/nashorn/internal/codegen/types/ObjectType.java	Mon Oct 27 14:36:13 2014 -0700
    36.2 +++ b/src/jdk/nashorn/internal/codegen/types/ObjectType.java	Thu Nov 06 09:50:15 2014 -0800
    36.3 @@ -47,6 +47,7 @@
    36.4   * contain a class that is a more specialized object
    36.5   */
    36.6  class ObjectType extends Type {
    36.7 +    private static final long serialVersionUID = 1L;
    36.8  
    36.9      protected ObjectType() {
   36.10          this(Object.class);

    37.1 --- a/src/jdk/nashorn/internal/codegen/types/Type.java	Mon Oct 27 14:36:13 2014 -0700
    37.2 +++ b/src/jdk/nashorn/internal/codegen/types/Type.java	Thu Nov 06 09:50:15 2014 -0800
    37.3 @@ -47,9 +47,11 @@
    37.4  import static jdk.internal.org.objectweb.asm.Opcodes.T_INT;
    37.5  import static jdk.internal.org.objectweb.asm.Opcodes.T_LONG;
    37.6  import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
    37.7 +
    37.8  import java.io.DataInput;
    37.9  import java.io.DataOutput;
   37.10  import java.io.IOException;
   37.11 +import java.io.Serializable;
   37.12  import java.lang.invoke.CallSite;
   37.13  import java.lang.invoke.MethodHandle;
   37.14  import java.lang.invoke.MethodHandles;
   37.15 @@ -88,19 +90,20 @@
   37.16   * INTs rather than OBJECTs
   37.17   */
   37.18  
   37.19 -public abstract class Type implements Comparable<Type>, BytecodeOps {
   37.20 +public abstract class Type implements Comparable<Type>, BytecodeOps, Serializable {
   37.21 +    private static final long serialVersionUID = 1L;
   37.22  
   37.23      /** Human readable name for type */
   37.24 -    private final String name;
   37.25 +    private transient final String name;
   37.26  
   37.27      /** Descriptor for type */
   37.28 -    private final String descriptor;
   37.29 +    private transient final String descriptor;
   37.30  
   37.31      /** The "weight" of the type. Used for picking widest/least specific common type */
   37.32 -    private final int weight;
   37.33 +    private transient final int weight;
   37.34  
   37.35      /** How many bytecode slots does this type occupy */
   37.36 -    private final int slots;
   37.37 +    private transient final int slots;
   37.38  
   37.39      /** The class for this type */
   37.40      private final Class<?> clazz;
   37.41 @@ -113,7 +116,7 @@
   37.42              Collections.synchronizedMap(new WeakHashMap<Class<?>, jdk.internal.org.objectweb.asm.Type>());
   37.43  
   37.44      /** Internal ASM type for this Type - computed once at construction */
   37.45 -    private final jdk.internal.org.objectweb.asm.Type internalType;
   37.46 +    private transient final jdk.internal.org.objectweb.asm.Type internalType;
   37.47  
   37.48      /** Weights are used to decide which types are "wider" than other types */
   37.49      protected static final int MIN_WEIGHT = -1;
   37.50 @@ -583,6 +586,7 @@
   37.51      public int getSlots() {
   37.52          return slots;
   37.53      }
   37.54 +
   37.55      /**
   37.56       * Returns the widest or most common of two types
   37.57       *
   37.58 @@ -606,6 +610,18 @@
   37.59      }
   37.60  
   37.61      /**
   37.62 +     * Returns the widest or most common of two types, given as classes
   37.63 +     *
   37.64 +     * @param type0 type one
   37.65 +     * @param type1 type two
   37.66 +     *
   37.67 +     * @return the widest type
   37.68 +     */
   37.69 +    public static Class<?> widest(final Class<?> type0, final Class<?> type1) {
   37.70 +        return widest(Type.typeFor(type0), Type.typeFor(type1)).getTypeClass();
   37.71 +    }
   37.72 +
   37.73 +    /**
   37.74       * When doing widening for return types of a function or a ternary operator, it is not valid to widen a boolean to
   37.75       * anything other than object. Note that this wouldn't be necessary if {@code Type.widest} did not allow
   37.76       * boolean-to-number widening. Eventually, we should address it there, but it affects too many other parts of the
   37.77 @@ -934,6 +950,8 @@
   37.78       * This is the singleton for integer arrays
   37.79       */
   37.80      public static final ArrayType INT_ARRAY = new ArrayType(int[].class) {
   37.81 +        private static final long serialVersionUID = 1L;
   37.82 +
   37.83          @Override
   37.84          public void astore(final MethodVisitor method) {
   37.85              method.visitInsn(IASTORE);
   37.86 @@ -961,6 +979,8 @@
   37.87       * This is the singleton for long arrays
   37.88       */
   37.89      public static final ArrayType LONG_ARRAY = new ArrayType(long[].class) {
   37.90 +        private static final long serialVersionUID = 1L;
   37.91 +
   37.92          @Override
   37.93          public void astore(final MethodVisitor method) {
   37.94              method.visitInsn(LASTORE);
   37.95 @@ -988,6 +1008,8 @@
   37.96       * This is the singleton for numeric arrays
   37.97       */
   37.98      public static final ArrayType NUMBER_ARRAY = new ArrayType(double[].class) {
   37.99 +        private static final long serialVersionUID = 1L;
  37.100 +
  37.101          @Override
  37.102          public void astore(final MethodVisitor method) {
  37.103              method.visitInsn(DASTORE);
  37.104 @@ -1022,6 +1044,8 @@
  37.105  
  37.106      /** This type, always an object type, just a toString override */
  37.107      public static final Type THIS = new ObjectType() {
  37.108 +        private static final long serialVersionUID = 1L;
  37.109 +
  37.110          @Override
  37.111          public String toString() {
  37.112              return "this";
  37.113 @@ -1030,6 +1054,8 @@
  37.114  
  37.115      /** Scope type, always an object type, just a toString override */
  37.116      public static final Type SCOPE = new ObjectType() {
  37.117 +        private static final long serialVersionUID = 1L;
  37.118 +
  37.119          @Override
  37.120          public String toString() {
  37.121              return "scope";
  37.122 @@ -1041,6 +1067,7 @@
  37.123      }
  37.124  
  37.125      private abstract static class ValueLessType extends Type {
  37.126 +        private static final long serialVersionUID = 1L;
  37.127  
  37.128          ValueLessType(final String name) {
  37.129              super(name, Unknown.class, MIN_WEIGHT, 1);
  37.130 @@ -1092,6 +1119,8 @@
  37.131       * inference. It has the minimum type width
  37.132       */
  37.133      public static final Type UNKNOWN = new ValueLessType("<unknown>") {
  37.134 +        private static final long serialVersionUID = 1L;
  37.135 +
  37.136          @Override
  37.137          public String getDescriptor() {
  37.138              return "<unknown>";
  37.139 @@ -1108,6 +1137,7 @@
  37.140       * inference. It has the minimum type width
  37.141       */
  37.142      public static final Type SLOT_2 = new ValueLessType("<slot_2>") {
  37.143 +        private static final long serialVersionUID = 1L;
  37.144  
  37.145          @Override
  37.146          public String getDescriptor() {
  37.147 @@ -1124,4 +1154,8 @@
  37.148          cache.put(type.getTypeClass(), type);
  37.149          return type;
  37.150      }
  37.151 +
  37.152 +    protected final Object readResolve() {
  37.153 +        return Type.typeFor(clazz);
  37.154 +    }
  37.155  }