changeset 6614:c1af79d122ec jdk9-b20

Merge
author lana
date Fri, 20 Jun 2014 10:15:08 -0700
parents 9920b4b5752d b7b7eb358428
children 17b4a5e831b3
files
diffstat 148 files changed, 4997 insertions(+), 2823 deletions(-) [+]
line wrap: on
line diff
--- a/make/bsd/makefiles/fastdebug.make	Thu Jun 19 11:22:25 2014 -0700
+++ b/make/bsd/makefiles/fastdebug.make	Fri Jun 20 10:15:08 2014 -0700
@@ -24,37 +24,30 @@
 
 # Sets make macros for making debug version of VM
 
+# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
+# They may also specify FASTDEBUG_CFLAGS, but it defaults to DEBUG_CFLAGS.
+
+FASTDEBUG_CFLAGS$(FASTDEBUG_CFLAGS) = $(DEBUG_CFLAGS)
+
 # Compiler specific OPT_CFLAGS are passed in from gcc.make, sparcWorks.make
 OPT_CFLAGS/DEFAULT= $(OPT_CFLAGS)
 OPT_CFLAGS/BYFILE = $(OPT_CFLAGS/$@)$(OPT_CFLAGS/DEFAULT$(OPT_CFLAGS/$@))
 
 # (OPT_CFLAGS/SLOWER is also available, to alter compilation of buggy files)
 
-ifeq ($(BUILDARCH), ia64)
-  # Bug in GCC, causes hang.  -O1 will override the -O3 specified earlier
-  OPT_CFLAGS/callGenerator.o += -O1
-  OPT_CFLAGS/ciTypeFlow.o += -O1
-  OPT_CFLAGS/compile.o += -O1
-  OPT_CFLAGS/concurrentMarkSweepGeneration.o += -O1
-  OPT_CFLAGS/doCall.o += -O1
-  OPT_CFLAGS/generateOopMap.o += -O1
-  OPT_CFLAGS/generateOptoStub.o += -O1
-  OPT_CFLAGS/graphKit.o += -O1
-  OPT_CFLAGS/instanceKlass.o += -O1
-  OPT_CFLAGS/interpreterRT_ia64.o += -O1
-  OPT_CFLAGS/output.o += -O1
-  OPT_CFLAGS/parse1.o += -O1
-  OPT_CFLAGS/runtime.o += -O1
-  OPT_CFLAGS/synchronizer.o += -O1
-endif
-
-
 # If you set HOTSPARC_GENERIC=yes, you disable all OPT_CFLAGS settings
 CFLAGS$(HOTSPARC_GENERIC) += $(OPT_CFLAGS/BYFILE)
 
 # Set the environment variable HOTSPARC_GENERIC to "true"
 # to inhibit the effect of the previous line on CFLAGS.
 
+# The following lines are copied from debug.make, except that we
+# consult FASTDEBUG_CFLAGS instead of DEBUG_CFLAGS.
+# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
+DEBUG_CFLAGS/DEFAULT= $(FASTDEBUG_CFLAGS)
+DEBUG_CFLAGS/BYFILE = $(DEBUG_CFLAGS/$@)$(DEBUG_CFLAGS/DEFAULT$(DEBUG_CFLAGS/$@))
+CFLAGS += $(DEBUG_CFLAGS/BYFILE)
+
 # Linker mapfile
 MAPFILE = $(GAMMADIR)/make/bsd/makefiles/mapfile-vers-debug
 ifeq ($(OS_VENDOR), Darwin)
--- a/make/bsd/makefiles/gcc.make	Thu Jun 19 11:22:25 2014 -0700
+++ b/make/bsd/makefiles/gcc.make	Fri Jun 20 10:15:08 2014 -0700
@@ -19,7 +19,7 @@
 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 # or visit www.oracle.com if you need additional information or have any
 # questions.
-#  
+#
 #
 
 OS_VENDOR = $(shell uname -s)
@@ -80,7 +80,7 @@
     HOSTCC  = $(CC)
   endif
 
-  AS   = $(CC) -c 
+  AS  = $(CC) -c
 endif
 
 ifeq ($(OS_VENDOR), Darwin)
@@ -100,7 +100,7 @@
 endif
 
 ifeq ($(USE_CLANG), true)
-  # clang has precompiled headers support by default, but the user can switch
+  # Clang has precompiled headers support by default, but the user can switch
   # it off by using 'USE_PRECOMPILED_HEADER=0'.
   ifdef LP64
     ifeq ($(USE_PRECOMPILED_HEADER),)
@@ -112,29 +112,29 @@
     # Clang produces an error if the PCH file was compiled with other options than the actual compilation unit.
     USE_PRECOMPILED_HEADER=0
   endif
-  
+
   ifeq ($(USE_PRECOMPILED_HEADER),1)
-  
+
     ifndef LP64
       $(error " Precompiled Headers only supported on 64-bit platforms!")
     endif
-  
+
     PRECOMPILED_HEADER_DIR=.
     PRECOMPILED_HEADER_SRC=$(GAMMADIR)/src/share/vm/precompiled/precompiled.hpp
     PRECOMPILED_HEADER=$(PRECOMPILED_HEADER_DIR)/precompiled.hpp.pch
-  
+
     PCH_FLAG = -include precompiled.hpp
     PCH_FLAG/DEFAULT = $(PCH_FLAG)
     PCH_FLAG/NO_PCH = -DNO_PCH
     PCH_FLAG/BY_FILE = $(PCH_FLAG/$@)$(PCH_FLAG/DEFAULT$(PCH_FLAG/$@))
-  
+
     VM_PCH_FLAG/LIBJVM = $(PCH_FLAG/BY_FILE)
     VM_PCH_FLAG/AOUT =
     VM_PCH_FLAG = $(VM_PCH_FLAG/$(LINK_INTO))
-  
+
     # We only use precompiled headers for the JVM build
     CFLAGS += $(VM_PCH_FLAG)
- 
+
     # The following files are compiled at various optimization
     # levels due to optimization issues encountered at the
     # 'OPT_CFLAGS_DEFAULT' level. The Clang compiler issues a compile
@@ -149,7 +149,7 @@
     PCH_FLAG/sharedRuntimeTrig.o = $(PCH_FLAG/NO_PCH)
     PCH_FLAG/sharedRuntimeTrans.o = $(PCH_FLAG/NO_PCH)
     PCH_FLAG/unsafe.o = $(PCH_FLAG/NO_PCH)
-  
+
   endif
 else # ($(USE_CLANG), true)
   # check for precompiled headers support
@@ -272,21 +272,24 @@
 
 CFLAGS_WARN/DEFAULT = $(WARNINGS_ARE_ERRORS) $(WARNING_FLAGS)
 # Special cases
-CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@)) 
+CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
 # XXXDARWIN: for _dyld_bind_fully_image_containing_address
 ifeq ($(OS_VENDOR), Darwin)
   CFLAGS_WARN/os_bsd.o = $(CFLAGS_WARN/DEFAULT) -Wno-deprecated-declarations
 endif
 
+# optimization control flags (Used by fastdebug and release variants)
+OPT_CFLAGS/NOOPT=-O0
+ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
+  # Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
+  OPT_CFLAGS/DEBUG=-Og
+else
+  # Allow no optimizations.
+ OPT_CFLAGS/DEBUG=-O0
+endif
 OPT_CFLAGS/SIZE=-Os
 OPT_CFLAGS/SPEED=-O3
 
-# Hotspot uses very unstrict aliasing turn this optimization off
-# This option is added to CFLAGS rather than OPT_CFLAGS
-# so that OPT_CFLAGS overrides get this option too.
-CFLAGS += -fno-strict-aliasing
-
-# The flags to use for an Optimized g++ build
 ifeq ($(OS_VENDOR), Darwin)
   # use -Os by default, unless -O3 can be proved to be worth the cost, as per policy
   # <https://wiki.openjdk.java.net/display/MacOSXPort/Compiler+Errata>
@@ -295,6 +298,11 @@
   OPT_CFLAGS_DEFAULT ?= SPEED
 endif
 
+# Hotspot uses very unstrict aliasing turn this optimization off
+# This option is added to CFLAGS rather than OPT_CFLAGS
+# so that OPT_CFLAGS overrides get this option too.
+CFLAGS += -fno-strict-aliasing
+
 ifdef OPT_CFLAGS
   ifneq ("$(origin OPT_CFLAGS)", "command line")
     $(error " Use OPT_EXTRAS instead of OPT_CFLAGS to add extra flags to OPT_CFLAGS.")
@@ -309,8 +317,6 @@
 OPT_CFLAGS += -fno-expensive-optimizations
 endif
 
-OPT_CFLAGS/NOOPT=-O0
-
 # Work around some compiler bugs.
 ifeq ($(USE_CLANG), true)
   ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 2), 1)
@@ -338,7 +344,7 @@
 endif
 
 ifeq ($(OS_VENDOR), Darwin)
-  # Setting these parameters makes it an error to link to macosx APIs that are 
+  # Setting these parameters makes it an error to link to macosx APIs that are
   # newer than the given OS version and makes the linked binaries compatible even
   # if built on a newer version of the OS.
   # The expected format is X.Y.Z
@@ -371,10 +377,22 @@
 
 ifeq ($(USE_CLANG),)
   # statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
-  ifneq ("${CC_VER_MAJOR}", "2")
+  ifneq ($(CC_VER_MAJOR), 2)
     STATIC_LIBGCC += -static-libgcc
   endif
 
+  ifneq ($(OS_VENDOR), Darwin)
+    ifneq (, findstring(debug,$(BUILD_FLAVOR)))
+      # for relocations read-only
+      LFLAGS += -Xlinker -z -Xlinker relro
+
+      ifeq ($(BUILD_FLAVOR), debug)
+        # disable incremental relocations linking
+        LFLAGS += -Xlinker -z -Xlinker now
+      endif
+    endif
+  endif
+
   ifeq ($(BUILDARCH), ia64)
     LFLAGS += -Wl,-relax
   endif
@@ -425,6 +443,14 @@
   CFLAGS += -flimit-debug-info
 endif
 
+ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
+  # Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
+  DEBUG_CFLAGS=-Og
+else
+  # Allow no optimizations.
+  DEBUG_CFLAGS=-O0
+endif
+
 # DEBUG_BINARIES uses full -g debug information for all configs
 ifeq ($(DEBUG_BINARIES), true)
   CFLAGS += -g
@@ -441,9 +467,14 @@
   DEBUG_CFLAGS/ppc   = -g
   DEBUG_CFLAGS += $(DEBUG_CFLAGS/$(BUILDARCH))
   ifeq ($(DEBUG_CFLAGS/$(BUILDARCH)),)
-  DEBUG_CFLAGS += -gstabs
+      ifeq ($(USE_CLANG), true)
+        # Clang doesn't understand -gstabs
+        DEBUG_CFLAGS += -g
+      else
+        DEBUG_CFLAGS += -gstabs
+      endif
   endif
-  
+
   ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
     FASTDEBUG_CFLAGS/ia64  = -g
     FASTDEBUG_CFLAGS/amd64 = -g
@@ -458,7 +489,7 @@
         FASTDEBUG_CFLAGS += -gstabs
       endif
     endif
-  
+
     OPT_CFLAGS/ia64  = -g
     OPT_CFLAGS/amd64 = -g
     OPT_CFLAGS/arm   = -g
@@ -475,6 +506,18 @@
   endif
 endif
 
+ifeq ($(USE_CLANG),)
+  # Enable bounds checking.
+  # _FORTIFY_SOURCE appears in GCC 4.0+
+  ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 3 \) )" "1"
+    # compile time size bounds checks
+    FASTDEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1
+
+    # and runtime size bounds checks and paranoid stack smashing checks.
+    DEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1
+  endif
+endif
+
 # If we are building HEADLESS, pass on to VM
 # so it can set the java.awt.headless property
 ifdef HEADLESS
--- a/make/linux/makefiles/fastdebug.make	Thu Jun 19 11:22:25 2014 -0700
+++ b/make/linux/makefiles/fastdebug.make	Fri Jun 20 10:15:08 2014 -0700
@@ -24,6 +24,11 @@
 
 # Sets make macros for making debug version of VM
 
+# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
+# They may also specify FASTDEBUG_CFLAGS, but it defaults to DEBUG_CFLAGS.
+
+FASTDEBUG_CFLAGS$(FASTDEBUG_CFLAGS) = $(DEBUG_CFLAGS)
+
 # Compiler specific OPT_CFLAGS are passed in from gcc.make, sparcWorks.make
 OPT_CFLAGS/DEFAULT= $(OPT_CFLAGS)
 OPT_CFLAGS/BYFILE = $(OPT_CFLAGS/$@)$(OPT_CFLAGS/DEFAULT$(OPT_CFLAGS/$@))
@@ -54,6 +59,12 @@
 
 # Set the environment variable HOTSPARC_GENERIC to "true"
 # to inhibit the effect of the previous line on CFLAGS.
+# The following lines are copied from debug.make, except that we
+# consult FASTDEBUG_CFLAGS instead of DEBUG_CFLAGS.
+# Compiler specific DEBUG_CFLAGS are passed in from gcc.make, sparcWorks.make
+DEBUG_CFLAGS/DEFAULT= $(FASTDEBUG_CFLAGS)
+DEBUG_CFLAGS/BYFILE = $(DEBUG_CFLAGS/$@)$(DEBUG_CFLAGS/DEFAULT$(DEBUG_CFLAGS/$@))
+CFLAGS += $(DEBUG_CFLAGS/BYFILE)
 
 # Linker mapfile
 MAPFILE = $(GAMMADIR)/make/linux/makefiles/mapfile-vers-debug
--- a/make/linux/makefiles/gcc.make	Thu Jun 19 11:22:25 2014 -0700
+++ b/make/linux/makefiles/gcc.make	Fri Jun 20 10:15:08 2014 -0700
@@ -19,7 +19,7 @@
 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 # or visit www.oracle.com if you need additional information or have any
 # questions.
-#  
+#
 #
 
 #------------------------------------------------------------------------
@@ -62,7 +62,6 @@
   CC_VER_MINOR := $(shell $(CC) -dumpversion | sed 's/egcs-//' | cut -d'.' -f2)
 endif
 
-
 ifeq ($(USE_CLANG), true)
   # Clang has precompiled headers support by default, but the user can switch
   # it off by using 'USE_PRECOMPILED_HEADER=0'.
@@ -104,7 +103,7 @@
     # But Clang doesn't support a precompiled header which was compiled with -O3
     # to be used in a compilation unit which uses '-O0'. We could also prepare an
     # extra '-O0' PCH file for the opt build and use it here, but it's probably
-    # not worth the effoert as long as only two files need this special handling.
+    # not worth the effort as long as only two files need this special handling.
     PCH_FLAG/loopTransform.o = $(PCH_FLAG/NO_PCH)
     PCH_FLAG/sharedRuntimeTrig.o = $(PCH_FLAG/NO_PCH)
     PCH_FLAG/sharedRuntimeTrans.o = $(PCH_FLAG/NO_PCH)
@@ -226,19 +225,28 @@
 endif
 
 CFLAGS_WARN/DEFAULT = $(WARNINGS_ARE_ERRORS) $(WARNING_FLAGS)
+
 # Special cases
-CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@)) 
+CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
 
-# The flags to use for an Optimized g++ build
+# optimization control flags (Used by fastdebug and release variants)
+OPT_CFLAGS/NOOPT=-O0
+ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
+  # Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
+  OPT_CFLAGS/DEBUG=-Og
+else
+  # Allow no optimizations.
+  OPT_CFLAGS/DEBUG=-O0
+endif
 OPT_CFLAGS/SIZE=-Os
 OPT_CFLAGS/SPEED=-O3
 
+OPT_CFLAGS_DEFAULT ?= SPEED
+
 # Hotspot uses very unstrict aliasing turn this optimization off
 # This option is added to CFLAGS rather than OPT_CFLAGS
 # so that OPT_CFLAGS overrides get this option too.
-CFLAGS += -fno-strict-aliasing 
-
-OPT_CFLAGS_DEFAULT ?= SPEED
+CFLAGS += -fno-strict-aliasing
 
 ifdef OPT_CFLAGS
   ifneq ("$(origin OPT_CFLAGS)", "command line")
@@ -248,14 +256,12 @@
 
 OPT_CFLAGS = $(OPT_CFLAGS/$(OPT_CFLAGS_DEFAULT)) $(OPT_EXTRAS)
 
-# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp 
+# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp
 # if we use expensive-optimizations
 ifeq ($(BUILDARCH), ia64)
 OPT_CFLAGS += -fno-expensive-optimizations
 endif
 
-OPT_CFLAGS/NOOPT=-O0
-
 # Work around some compiler bugs.
 ifeq ($(USE_CLANG), true)
   ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 2), 1)
@@ -271,7 +277,7 @@
 # Flags for generating make dependency flags.
 DEPFLAGS = -MMD -MP -MF $(DEP_DIR)/$(@:%=%.d)
 ifeq ($(USE_CLANG),)
-  ifneq ("${CC_VER_MAJOR}", "2")
+  ifneq ($(CC_VER_MAJOR), 2)
     DEPFLAGS += -fpch-deps
   endif
 endif
@@ -282,21 +288,26 @@
 # statically link libstdc++.so, work with gcc but ignored by g++
 STATIC_STDCXX = -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic
 
+# Enable linker optimization
+LFLAGS += -Xlinker -O1
+
 ifeq ($(USE_CLANG),)
-  # statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
-  ifneq ("${CC_VER_MAJOR}", "2")
-    STATIC_LIBGCC += -static-libgcc
+  STATIC_LIBGCC += -static-libgcc
+
+  ifneq (, findstring(debug,$(BUILD_FLAVOR)))
+    # for relocations read-only
+    LFLAGS += -Xlinker -z -Xlinker relro
+
+    ifeq ($(BUILD_FLAVOR), debug)
+      # disable incremental relocations linking
+      LFLAGS += -Xlinker -z -Xlinker now
+    endif
   endif
 
   ifeq ($(BUILDARCH), ia64)
     LFLAGS += -Wl,-relax
   endif
-endif
 
-# Enable linker optimization
-LFLAGS += -Xlinker -O1
-
-ifeq ($(USE_CLANG),)
   # If this is a --hash-style=gnu system, use --hash-style=both
   #   The gnu .hash section won't work on some Linux systems like SuSE 10.
   _HAS_HASH_STYLE_GNU:=$(shell $(CC) -dumpspecs | grep -- '--hash-style=gnu')
@@ -333,6 +344,14 @@
   CFLAGS += -flimit-debug-info
 endif
 
+ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
+  # Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
+  DEBUG_CFLAGS=-Og
+else
+  # Allow no optimizations.
+  DEBUG_CFLAGS=-O0
+endif
+
 # DEBUG_BINARIES uses full -g debug information for all configs
 ifeq ($(DEBUG_BINARIES), true)
   CFLAGS += -g
@@ -355,6 +374,18 @@
   endif
 endif
 
+ifeq ($(USE_CLANG),)
+  # Enable bounds checking.
+  # _FORTIFY_SOURCE appears in GCC 4.0+
+  ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 3 \) )" "1"
+    # compile time size bounds checks
+    FASTDEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1
+
+    # and runtime size bounds checks and paranoid stack smashing checks.
+    DEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1
+  endif
+endif
+
 # If we are building HEADLESS, pass on to VM
 # so it can set the java.awt.headless property
 ifdef HEADLESS
--- a/make/solaris/makefiles/gcc.make	Thu Jun 19 11:22:25 2014 -0700
+++ b/make/solaris/makefiles/gcc.make	Fri Jun 20 10:15:08 2014 -0700
@@ -19,7 +19,7 @@
 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 # or visit www.oracle.com if you need additional information or have any
 # questions.
-#  
+#
 #
 
 #------------------------------------------------------------------------
@@ -40,7 +40,7 @@
 CC_VER_MAJOR := $(shell $(CC) -dumpversion | sed 's/egcs-//' | cut -d'.' -f1)
 CC_VER_MINOR := $(shell $(CC) -dumpversion | sed 's/egcs-//' | cut -d'.' -f2)
 
-# Check for the versions of C++ and C compilers ($CXX and $CC) used. 
+# Check for the versions of C++ and C compilers ($CXX and $CC) used.
 
 # Get the last thing on the line that looks like x.x+ (x is a digit).
 COMPILER_REV := \
@@ -98,7 +98,7 @@
 
 ifeq ($(BUILDARCH), amd64)
 ASFLAGS += -march=k8  -march=amd64
-LFLAGS += -march=k8 
+LFLAGS += -march=k8
 endif
 
 
@@ -115,21 +115,44 @@
 endif
 
 
-# Compiler warnings are treated as errors 
-WARNINGS_ARE_ERRORS = -Werror 
+# Compiler warnings are treated as errors
+WARNINGS_ARE_ERRORS = -Werror
+
 # Enable these warnings. See 'info gcc' about details on these options
 WARNING_FLAGS = -Wpointer-arith -Wconversion -Wsign-compare -Wundef -Wformat=2
 CFLAGS_WARN/DEFAULT = $(WARNINGS_ARE_ERRORS) $(WARNING_FLAGS)
-# Special cases 
-CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))  
 
-# The flags to use for an Optimized g++ build
-OPT_CFLAGS += -O3
+# Special cases
+CFLAGS_WARN/BYFILE = $(CFLAGS_WARN/$@)$(CFLAGS_WARN/DEFAULT$(CFLAGS_WARN/$@))
+
+# optimization control flags (Used by fastdebug and release variants)
+OPT_CFLAGS/NOOPT=-O0
+ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
+  # Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
+  OPT_CFLAGS/DEBUG=-Og
++else
+  # Allow no optimizations.
+  OPT_CFLAGS/DEBUG=-O0
+endif
+OPT_CFLAGS/SIZE=-Os
+OPT_CFLAGS/SPEED=-O3
+
+OPT_CFLAGS_DEFAULT ?= SPEED
 
 # Hotspot uses very unstrict aliasing turn this optimization off
-OPT_CFLAGS += -fno-strict-aliasing
+# This option is added to CFLAGS rather than OPT_CFLAGS
+# so that OPT_CFLAGS overrides get this option too.
+CFLAGS += -fno-strict-aliasing
 
-# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp 
+ifdef OPT_CFLAGS
+  ifneq ("$(origin OPT_CFLAGS)", "command line")
+    $(error " Use OPT_EXTRAS instead of OPT_CFLAGS to add extra flags to OPT_CFLAGS.")
+  endif
+endif
+
+OPT_CFLAGS = $(OPT_CFLAGS/$(OPT_CFLAGS_DEFAULT)) $(OPT_EXTRAS)
+
+# The gcc compiler segv's on ia64 when compiling bytecodeInterpreter.cpp
 # if we use expensive-optimizations
 # Note: all ia64 setting reflect the ones for linux
 # No actial testing was performed: there is no Solaris on ia64 presently
@@ -137,10 +160,20 @@
 OPT_CFLAGS/bytecodeInterpreter.o += -fno-expensive-optimizations
 endif
 
-OPT_CFLAGS/NOOPT=-O0
+# Work around some compiler bugs.
+ifeq ($(USE_CLANG), true)
+  ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 2), 1)
+    OPT_CFLAGS/loopTransform.o += $(OPT_CFLAGS/NOOPT)
+  endif
+else
+  # 6835796. Problem in GCC 4.3.0 with mulnode.o optimized compilation.
+  ifeq ($(shell expr $(CC_VER_MAJOR) = 4 \& $(CC_VER_MINOR) = 3), 1)
+    OPT_CFLAGS/mulnode.o += $(OPT_CFLAGS/NOOPT)
+  endif
+endif
 
 # Flags for generating make dependency flags.
-ifneq ("${CC_VER_MAJOR}", "2")
+ifneq ($(CC_VER_MAJOR), 2)
 DEPFLAGS = -fpch-deps -MMD -MP -MF $(DEP_DIR)/$(@:%=%.d)
 endif
 
@@ -155,26 +188,37 @@
 # statically link libstdc++.so, work with gcc but ignored by g++
 STATIC_STDCXX = -Wl,-Bstatic -lstdc++ -Wl,-Bdynamic
 
-# statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
-ifneq ("${CC_VER_MAJOR}", "2")
-STATIC_LIBGCC += -static-libgcc
-endif
-
-ifeq ($(BUILDARCH), ia64)
-# Note: all ia64 setting reflect the ones for linux
-# No actial testing was performed: there is no Solaris on ia64 presently
-LFLAGS += -Wl,-relax
-endif
 
 ifdef USE_GNULD
-# Enable linker optimization
-LFLAGS += -Xlinker -O1
+  # statically link libgcc and/or libgcc_s, libgcc does not exist before gcc-3.x.
+  ifneq ($(CC_VER_MAJOR), 2)
+    STATIC_LIBGCC += -static-libgcc
+  endif
 
-# Use $(MAPFLAG:FILENAME=real_file_name) to specify a map file.
-MAPFLAG = -Xlinker --version-script=FILENAME 
-else 
-MAPFLAG = -Xlinker -M -Xlinker FILENAME 
-endif 
+  # Enable linker optimization
+  LFLAGS += -Xlinker -O1
+
+  ifneq (, findstring(debug,$(BUILD_FLAVOR)))
+    # for relocations read-only
+    LFLAGS += -Xlinker -z -Xlinker relro
+
+    ifeq ($(BUILD_FLAVOR), debug)
+      # disable incremental relocations linking
+      LFLAGS += -Xlinker -z -Xlinker now
+    endif
+  endif
+
+  ifeq ($(BUILDARCH), ia64)
+    # Note: all ia64 setting reflect the ones for linux
+    # No actual testing was performed: there is no Solaris on ia64 presently
+    LFLAGS += -Wl,-relax
+  endif
+
+  # Use $(MAPFLAG:FILENAME=real_file_name) to specify a map file.
+  MAPFLAG = -Xlinker --version-script=FILENAME
+else
+  MAPFLAG = -Xlinker -M -Xlinker FILENAME
+endif
 
 # Use $(SONAMEFLAG:SONAME=soname) to specify the intrinsic name of a shared obj
 SONAMEFLAG = -Xlinker -soname=SONAME
@@ -185,15 +229,34 @@
 #------------------------------------------------------------------------
 # Debug flags
 
-# Use the stabs format for debugging information (this is the default 
-# on gcc-2.91). It's good enough, has all the information about line 
-# numbers and local variables, and libjvm.so is only about 16M. 
-# Change this back to "-g" if you want the most expressive format. 
-# (warning: that could easily inflate libjvm.so to 150M!) 
-# Note: The Itanium gcc compiler crashes when using -gstabs. 
-DEBUG_CFLAGS/ia64  = -g 
-DEBUG_CFLAGS/amd64 = -g 
-DEBUG_CFLAGS += $(DEBUG_CFLAGS/$(BUILDARCH)) 
-ifeq ($(DEBUG_CFLAGS/$(BUILDARCH)),) 
-DEBUG_CFLAGS += -gstabs 
-endif 
+ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 8 \) \))" "1"
+  # Allow basic optimizations which don't distrupt debugging. (Principally dead code elimination)
+  DEBUG_CFLAGS=-Og
+else
+  # Allow no optimizations.
+  DEBUG_CFLAGS=-O0
+endif
+
+
+# Use the stabs format for debugging information (this is the default
+# on gcc-2.91). It's good enough, has all the information about line
+# numbers and local variables, and libjvm.so is only about 16M.
+# Change this back to "-g" if you want the most expressive format.
+# (warning: that could easily inflate libjvm.so to 150M!)
+# Note: The Itanium gcc compiler crashes when using -gstabs.
+DEBUG_CFLAGS/ia64  = -g
+DEBUG_CFLAGS/amd64 = -g
+DEBUG_CFLAGS += $(DEBUG_CFLAGS/$(BUILDARCH))
+ifeq ($(DEBUG_CFLAGS/$(BUILDARCH)),)
+  DEBUG_CFLAGS += -gstabs
+endif
+
+# Enable bounds checking.
+# _FORTIFY_SOURCE appears in GCC 4.0+
+ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 3 \) )" "1"
+  # compile time size bounds checks
+  FASTDEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=1
+
+  # and runtime size bounds checks and paranoid stack smashing checks.
+  DEBUG_CFLAGS += -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2 -fstack-protector-all --param ssp-buffer-size=1
+endif
--- a/src/cpu/ppc/vm/ppc.ad	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/ppc/vm/ppc.ad	Fri Jun 20 10:15:08 2014 -0700
@@ -1285,9 +1285,9 @@
 void MachConstantBaseNode::postalloc_expand(GrowableArray <Node *> *nodes, PhaseRegAlloc *ra_) {
   Compile *C = ra_->C;
 
-  iRegPdstOper *op_dst = new (C) iRegPdstOper();
-  MachNode *m1 = new (C) loadToc_hiNode();
-  MachNode *m2 = new (C) loadToc_loNode();
+  iRegPdstOper *op_dst = new iRegPdstOper();
+  MachNode *m1 = new loadToc_hiNode();
+  MachNode *m2 = new loadToc_loNode();
 
   m1->add_req(NULL);
   m2->add_req(NULL, m1);
@@ -2232,9 +2232,9 @@
 MachTypeNode *Matcher::make_decode_node(Compile *C) {
   assert(Universe::narrow_oop_base() == NULL && Universe::narrow_oop_shift() == 0,
          "This method is only implemented for unscaled cOops mode so far");
-  MachTypeNode *decode = new (C) decodeN_unscaledNode();
-  decode->set_opnd_array(0, new (C) iRegPdstOper());
-  decode->set_opnd_array(1, new (C) iRegNsrcOper());
+  MachTypeNode *decode = new decodeN_unscaledNode();
+  decode->set_opnd_array(0, new iRegPdstOper());
+  decode->set_opnd_array(1, new iRegNsrcOper());
   return decode;
 }
 */
@@ -2600,20 +2600,20 @@
   const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000;
   if (large_constant_pool) {
     // Create new nodes.
-    loadConL_hiNode *m1 = new (C) loadConL_hiNode();
-    loadConL_loNode *m2 = new (C) loadConL_loNode();
+    loadConL_hiNode *m1 = new loadConL_hiNode();
+    loadConL_loNode *m2 = new loadConL_loNode();
 
     // inputs for new nodes
     m1->add_req(NULL, toc);
     m2->add_req(NULL, m1);
 
     // operands for new nodes
-    m1->_opnds[0] = new (C) iRegLdstOper(); // dst
-    m1->_opnds[1] = immSrc;                 // src
-    m1->_opnds[2] = new (C) iRegPdstOper(); // toc
-    m2->_opnds[0] = new (C) iRegLdstOper(); // dst
-    m2->_opnds[1] = immSrc;                 // src
-    m2->_opnds[2] = new (C) iRegLdstOper(); // base
+    m1->_opnds[0] = new iRegLdstOper(); // dst
+    m1->_opnds[1] = immSrc;             // src
+    m1->_opnds[2] = new iRegPdstOper(); // toc
+    m2->_opnds[0] = new iRegLdstOper(); // dst
+    m2->_opnds[1] = immSrc;             // src
+    m2->_opnds[2] = new iRegLdstOper(); // base
 
     // Initialize ins_attrib TOC fields.
     m1->_const_toc_offset = -1;
@@ -2633,15 +2633,15 @@
     nodes._last = nodes._large_lo;
     assert(m2->bottom_type()->isa_long(), "must be long");
   } else {
-    loadConLNode *m2 = new (C) loadConLNode();
+    loadConLNode *m2 = new loadConLNode();
 
     // inputs for new nodes
     m2->add_req(NULL, toc);
 
     // operands for new nodes
-    m2->_opnds[0] = new (C) iRegLdstOper(); // dst
-    m2->_opnds[1] = immSrc;                 // src
-    m2->_opnds[2] = new (C) iRegPdstOper(); // toc
+    m2->_opnds[0] = new iRegLdstOper(); // dst
+    m2->_opnds[1] = immSrc;             // src
+    m2->_opnds[2] = new iRegPdstOper(); // toc
 
     // Initialize ins_attrib instruction offset.
     m2->_cbuf_insts_offset = -1;
@@ -2750,20 +2750,20 @@
     const bool large_constant_pool = true; // TODO: PPC port C->cfg()->_consts_size > 4000;
     if (large_constant_pool) {
       // Create new nodes.
-      loadConP_hiNode *m1 = new (C) loadConP_hiNode();
-      loadConP_loNode *m2 = new (C) loadConP_loNode();
+      loadConP_hiNode *m1 = new loadConP_hiNode();
+      loadConP_loNode *m2 = new loadConP_loNode();
 
       // inputs for new nodes
       m1->add_req(NULL, n_toc);
       m2->add_req(NULL, m1);
 
       // operands for new nodes
-      m1->_opnds[0] = new (C) iRegPdstOper(); // dst
-      m1->_opnds[1] = op_src;                 // src
-      m1->_opnds[2] = new (C) iRegPdstOper(); // toc
-      m2->_opnds[0] = new (C) iRegPdstOper(); // dst
-      m2->_opnds[1] = op_src;                 // src
-      m2->_opnds[2] = new (C) iRegLdstOper(); // base
+      m1->_opnds[0] = new iRegPdstOper(); // dst
+      m1->_opnds[1] = op_src;             // src
+      m1->_opnds[2] = new iRegPdstOper(); // toc
+      m2->_opnds[0] = new iRegPdstOper(); // dst
+      m2->_opnds[1] = op_src;             // src
+      m2->_opnds[2] = new iRegLdstOper(); // base
 
       // Initialize ins_attrib TOC fields.
       m1->_const_toc_offset = -1;
@@ -2777,15 +2777,15 @@
       nodes->push(m2);
       assert(m2->bottom_type()->isa_ptr(), "must be ptr");
     } else {
-      loadConPNode *m2 = new (C) loadConPNode();
+      loadConPNode *m2 = new loadConPNode();
 
       // inputs for new nodes
       m2->add_req(NULL, n_toc);
 
       // operands for new nodes
-      m2->_opnds[0] = new (C) iRegPdstOper(); // dst
-      m2->_opnds[1] = op_src;                 // src
-      m2->_opnds[2] = new (C) iRegPdstOper(); // toc
+      m2->_opnds[0] = new iRegPdstOper(); // dst
+      m2->_opnds[1] = op_src;             // src
+      m2->_opnds[2] = new iRegPdstOper(); // toc
 
       // Register allocation for new nodes.
       ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@@ -2802,9 +2802,9 @@
 
     MachNode *m2;
     if (large_constant_pool) {
-      m2 = new (C) loadConFCompNode();
+      m2 = new loadConFCompNode();
     } else {
-      m2 = new (C) loadConFNode();
+      m2 = new loadConFNode();
     }
     // inputs for new nodes
     m2->add_req(NULL, n_toc);
@@ -2812,7 +2812,7 @@
     // operands for new nodes
     m2->_opnds[0] = op_dst;
     m2->_opnds[1] = op_src;
-    m2->_opnds[2] = new (C) iRegPdstOper(); // constanttablebase
+    m2->_opnds[2] = new iRegPdstOper(); // constanttablebase
 
     // register allocation for new nodes
     ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@@ -2826,9 +2826,9 @@
 
     MachNode *m2;
     if (large_constant_pool) {
-      m2 = new (C) loadConDCompNode();
+      m2 = new loadConDCompNode();
     } else {
-      m2 = new (C) loadConDNode();
+      m2 = new loadConDNode();
     }
     // inputs for new nodes
     m2->add_req(NULL, n_toc);
@@ -2836,7 +2836,7 @@
     // operands for new nodes
     m2->_opnds[0] = op_dst;
     m2->_opnds[1] = op_src;
-    m2->_opnds[2] = new (C) iRegPdstOper(); // constanttablebase
+    m2->_opnds[2] = new iRegPdstOper(); // constanttablebase
 
     // register allocation for new nodes
     ra_->set_pair(m2->_idx, ra_->get_reg_second(this), ra_->get_reg_first(this));
@@ -2918,15 +2918,15 @@
 
     if (VM_Version::has_isel()) {
       // use isel instruction with Power 7
-      cmpP_reg_imm16Node *n_compare  = new (C) cmpP_reg_imm16Node();
-      encodeP_subNode    *n_sub_base = new (C) encodeP_subNode();
-      encodeP_shiftNode  *n_shift    = new (C) encodeP_shiftNode();
-      cond_set_0_oopNode *n_cond_set = new (C) cond_set_0_oopNode();
+      cmpP_reg_imm16Node *n_compare  = new cmpP_reg_imm16Node();
+      encodeP_subNode    *n_sub_base = new encodeP_subNode();
+      encodeP_shiftNode  *n_shift    = new encodeP_shiftNode();
+      cond_set_0_oopNode *n_cond_set = new cond_set_0_oopNode();
 
       n_compare->add_req(n_region, n_src);
       n_compare->_opnds[0] = op_crx;
       n_compare->_opnds[1] = op_src;
-      n_compare->_opnds[2] = new (C) immL16Oper(0);
+      n_compare->_opnds[2] = new immL16Oper(0);
 
       n_sub_base->add_req(n_region, n_src);
       n_sub_base->_opnds[0] = op_dst;
@@ -2956,10 +2956,10 @@
 
     } else {
       // before Power 7
-      moveRegNode        *n_move     = new (C) moveRegNode();
-      cmpP_reg_imm16Node *n_compare  = new (C) cmpP_reg_imm16Node();
-      encodeP_shiftNode  *n_shift    = new (C) encodeP_shiftNode();
-      cond_sub_baseNode  *n_sub_base = new (C) cond_sub_baseNode();
+      moveRegNode        *n_move     = new moveRegNode();
+      cmpP_reg_imm16Node *n_compare  = new cmpP_reg_imm16Node();
+      encodeP_shiftNode  *n_shift    = new encodeP_shiftNode();
+      cond_sub_baseNode  *n_sub_base = new cond_sub_baseNode();
 
       n_move->add_req(n_region, n_src);
       n_move->_opnds[0] = op_dst;
@@ -2971,7 +2971,7 @@
 
       n_compare->_opnds[0] = op_crx;
       n_compare->_opnds[1] = op_src;
-      n_compare->_opnds[2] = new (C) immL16Oper(0);
+      n_compare->_opnds[2] = new immL16Oper(0);
 
       n_sub_base->add_req(n_region, n_compare, n_src);
       n_sub_base->_opnds[0] = op_dst;
@@ -3000,13 +3000,13 @@
 
   enc_class postalloc_expand_encode_oop_not_null(iRegNdst dst, iRegPdst src) %{
 
-    encodeP_subNode *n1 = new (C) encodeP_subNode();
+    encodeP_subNode *n1 = new encodeP_subNode();
     n1->add_req(n_region, n_src);
     n1->_opnds[0] = op_dst;
     n1->_opnds[1] = op_src;
     n1->_bottom_type = _bottom_type;
 
-    encodeP_shiftNode *n2 = new (C) encodeP_shiftNode();
+    encodeP_shiftNode *n2 = new encodeP_shiftNode();
     n2->add_req(n_region, n1);
     n2->_opnds[0] = op_dst;
     n2->_opnds[1] = op_dst;
@@ -3020,13 +3020,13 @@
   %}
 
   enc_class postalloc_expand_decode_oop(iRegPdst dst, iRegNsrc src, flagsReg crx) %{
-    decodeN_shiftNode *n_shift    = new (C) decodeN_shiftNode();
-    cmpN_reg_imm0Node *n_compare  = new (C) cmpN_reg_imm0Node();
+    decodeN_shiftNode *n_shift    = new decodeN_shiftNode();
+    cmpN_reg_imm0Node *n_compare  = new cmpN_reg_imm0Node();
 
     n_compare->add_req(n_region, n_src);
     n_compare->_opnds[0] = op_crx;
     n_compare->_opnds[1] = op_src;
-    n_compare->_opnds[2] = new (C) immN_0Oper(TypeNarrowOop::NULL_PTR);
+    n_compare->_opnds[2] = new immN_0Oper(TypeNarrowOop::NULL_PTR);
 
     n_shift->add_req(n_region, n_src);
     n_shift->_opnds[0] = op_dst;
@@ -3036,13 +3036,13 @@
     if (VM_Version::has_isel()) {
       // use isel instruction with Power 7
 
-      decodeN_addNode *n_add_base = new (C) decodeN_addNode();
+      decodeN_addNode *n_add_base = new decodeN_addNode();
       n_add_base->add_req(n_region, n_shift);
       n_add_base->_opnds[0] = op_dst;
       n_add_base->_opnds[1] = op_dst;
       n_add_base->_bottom_type = _bottom_type;
 
-      cond_set_0_ptrNode *n_cond_set = new (C) cond_set_0_ptrNode();
+      cond_set_0_ptrNode *n_cond_set = new cond_set_0_ptrNode();
       n_cond_set->add_req(n_region, n_compare, n_add_base);
       n_cond_set->_opnds[0] = op_dst;
       n_cond_set->_opnds[1] = op_crx;
@@ -3064,7 +3064,7 @@
 
     } else {
       // before Power 7
-      cond_add_baseNode *n_add_base = new (C) cond_add_baseNode();
+      cond_add_baseNode *n_add_base = new cond_add_baseNode();
 
       n_add_base->add_req(n_region, n_compare, n_shift);
       n_add_base->_opnds[0] = op_dst;
@@ -3086,13 +3086,13 @@
   %}
 
   enc_class postalloc_expand_decode_oop_not_null(iRegPdst dst, iRegNsrc src) %{
-    decodeN_shiftNode *n1 = new (C) decodeN_shiftNode();
+    decodeN_shiftNode *n1 = new decodeN_shiftNode();
     n1->add_req(n_region, n_src);
     n1->_opnds[0] = op_dst;
     n1->_opnds[1] = op_src;
     n1->_bottom_type = _bottom_type;
 
-    decodeN_addNode *n2 = new (C) decodeN_addNode();
+    decodeN_addNode *n2 = new decodeN_addNode();
     n2->add_req(n_region, n1);
     n2->_opnds[0] = op_dst;
     n2->_opnds[1] = op_dst;
@@ -3388,7 +3388,7 @@
     // Create new nodes.
 
     // Make an operand with the bit pattern to load as float.
-    immLOper *op_repl = new (C) immLOper((jlong)replicate_immF(op_src->constantF()));
+    immLOper *op_repl = new immLOper((jlong)replicate_immF(op_src->constantF()));
 
     loadConLNodesTuple loadConLNodes =
       loadConLNodesTuple_create(C, ra_, n_toc, op_repl,
@@ -3611,11 +3611,11 @@
 
     // Create the nodes for loading the IC from the TOC.
     loadConLNodesTuple loadConLNodes_IC =
-      loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong)Universe::non_oop_word()),
+      loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong)Universe::non_oop_word()),
                                 OptoReg::Name(R19_H_num), OptoReg::Name(R19_num));
 
     // Create the call node.
-    CallDynamicJavaDirectSchedNode *call = new (C) CallDynamicJavaDirectSchedNode();
+    CallDynamicJavaDirectSchedNode *call = new CallDynamicJavaDirectSchedNode();
     call->_method_handle_invoke = _method_handle_invoke;
     call->_vtable_index      = _vtable_index;
     call->_method            = _method;
@@ -3765,7 +3765,7 @@
 #if defined(ABI_ELFv2)
     jlong entry_address = (jlong) this->entry_point();
     assert(entry_address, "need address here");
-    loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper(entry_address),
+    loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper(entry_address),
                                                     OptoReg::Name(R12_H_num), OptoReg::Name(R12_num));
 #else
     // Get the struct that describes the function we are about to call.
@@ -3777,42 +3777,42 @@
     loadConLNodesTuple loadConLNodes_Toc;
 
     // Create nodes and operands for loading the entry point.
-    loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper(entry_address),
+    loadConLNodes_Entry = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper(entry_address),
                                                     OptoReg::Name(R12_H_num), OptoReg::Name(R12_num));
 
 
     // Create nodes and operands for loading the env pointer.
     if (fd->env() != NULL) {
-      loadConLNodes_Env = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong) fd->env()),
+      loadConLNodes_Env = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong) fd->env()),
                                                     OptoReg::Name(R11_H_num), OptoReg::Name(R11_num));
     } else {
       loadConLNodes_Env._large_hi = NULL;
       loadConLNodes_Env._large_lo = NULL;
       loadConLNodes_Env._small    = NULL;
-      loadConLNodes_Env._last = new (C) loadConL16Node();
-      loadConLNodes_Env._last->_opnds[0] = new (C) iRegLdstOper();
-      loadConLNodes_Env._last->_opnds[1] = new (C) immL16Oper(0);
+      loadConLNodes_Env._last = new loadConL16Node();
+      loadConLNodes_Env._last->_opnds[0] = new iRegLdstOper();
+      loadConLNodes_Env._last->_opnds[1] = new immL16Oper(0);
       ra_->set_pair(loadConLNodes_Env._last->_idx, OptoReg::Name(R11_H_num), OptoReg::Name(R11_num));
     }
 
     // Create nodes and operands for loading the Toc point.
-    loadConLNodes_Toc = loadConLNodesTuple_create(C, ra_, n_toc, new (C) immLOper((jlong) fd->toc()),
+    loadConLNodes_Toc = loadConLNodesTuple_create(C, ra_, n_toc, new immLOper((jlong) fd->toc()),
                                                   OptoReg::Name(R2_H_num), OptoReg::Name(R2_num));
 #endif // ABI_ELFv2
     // mtctr node
-    MachNode *mtctr = new (C) CallLeafDirect_mtctrNode();
+    MachNode *mtctr = new CallLeafDirect_mtctrNode();
 
     assert(loadConLNodes_Entry._last != NULL, "entry must exist");
     mtctr->add_req(0, loadConLNodes_Entry._last);
 
-    mtctr->_opnds[0] = new (C) iRegLdstOper();
-    mtctr->_opnds[1] = new (C) iRegLdstOper();
+    mtctr->_opnds[0] = new iRegLdstOper();
+    mtctr->_opnds[1] = new iRegLdstOper();
 
     // call node
-    MachCallLeafNode *call = new (C) CallLeafDirectNode();
+    MachCallLeafNode *call = new CallLeafDirectNode();
 
     call->_opnds[0] = _opnds[0];
-    call->_opnds[1] = new (C) methodOper((intptr_t) entry_address); // May get set later.
+    call->_opnds[1] = new methodOper((intptr_t) entry_address); // May get set later.
 
     // Make the new call node look like the old one.
     call->_name        = _name;
@@ -6050,9 +6050,9 @@
 
   format %{ "LoadN   $dst, $src \t// postalloc expanded" %} // mask
   postalloc_expand %{
-    MachNode *m1 = new (C) loadConN_hiNode();
-    MachNode *m2 = new (C) loadConN_loNode();
-    MachNode *m3 = new (C) clearMs32bNode();
+    MachNode *m1 = new loadConN_hiNode();
+    MachNode *m2 = new loadConN_loNode();
+    MachNode *m3 = new clearMs32bNode();
     m1->add_req(NULL);
     m2->add_req(NULL, m1);
     m3->add_req(NULL, m2);
@@ -6117,7 +6117,7 @@
   format %{ "LoadN   $dst, $src \t// postalloc expanded" %} // mask
   postalloc_expand %{
     // Load high bits into register. Sign extended.
-    MachNode *m1 = new (C) loadConNKlass_hiNode();
+    MachNode *m1 = new loadConNKlass_hiNode();
     m1->add_req(NULL);
     m1->_opnds[0] = op_dst;
     m1->_opnds[1] = op_src;
@@ -6127,7 +6127,7 @@
     MachNode *m2 = m1;
     if (!Assembler::is_uimm((jlong)Klass::encode_klass((Klass *)op_src->constant()), 31)) {
       // Value might be 1-extended. Mask out these bits.
-      m2 = new (C) clearMs32bNode();
+      m2 = new clearMs32bNode();
       m2->add_req(NULL, m1);
       m2->_opnds[0] = op_dst;
       m2->_opnds[1] = op_dst;
@@ -6135,7 +6135,7 @@
       nodes->push(m2);
     }
 
-    MachNode *m3 = new (C) loadConNKlass_loNode();
+    MachNode *m3 = new loadConNKlass_loNode();
     m3->add_req(NULL, m2);
     m3->_opnds[0] = op_dst;
     m3->_opnds[1] = op_src;
@@ -6987,14 +6987,14 @@
 
   format %{ "EncodePKlass $dst, $src\t// $src != Null, postalloc expanded" %}
   postalloc_expand %{
-    encodePKlass_sub_baseNode *n1 = new (C) encodePKlass_sub_baseNode();
+    encodePKlass_sub_baseNode *n1 = new encodePKlass_sub_baseNode();
     n1->add_req(n_region, n_base, n_src);
     n1->_opnds[0] = op_dst;
     n1->_opnds[1] = op_base;
     n1->_opnds[2] = op_src;
     n1->_bottom_type = _bottom_type;
 
-    encodePKlass_shiftNode *n2 = new (C) encodePKlass_shiftNode();
+    encodePKlass_shiftNode *n2 = new encodePKlass_shiftNode();
     n2->add_req(n_region, n1);
     n2->_opnds[0] = op_dst;
     n2->_opnds[1] = op_dst;
@@ -7064,14 +7064,14 @@
 
   format %{ "DecodeNKlass $dst =  $base + ($src << 3) \t// $src != NULL, postalloc expanded" %}
   postalloc_expand %{
-    decodeNKlass_add_baseNode *n1 = new (C) decodeNKlass_add_baseNode();
+    decodeNKlass_add_baseNode *n1 = new decodeNKlass_add_baseNode();
     n1->add_req(n_region, n_base, n_src);
     n1->_opnds[0] = op_dst;
     n1->_opnds[1] = op_base;
     n1->_opnds[2] = op_src;
     n1->_bottom_type = _bottom_type;
 
-    decodeNKlass_shiftNode *n2 = new (C) decodeNKlass_shiftNode();
+    decodeNKlass_shiftNode *n2 = new decodeNKlass_shiftNode();
     n2->add_req(n_region, n1);
     n2->_opnds[0] = op_dst;
     n2->_opnds[1] = op_dst;
@@ -9773,8 +9773,8 @@
     //
 
     // Create new nodes.
-    MachNode *m1 = new (C) loadConI16Node();
-    MachNode *m2 = new (C) cmovI_bso_stackSlotLNode();
+    MachNode *m1 = new loadConI16Node();
+    MachNode *m2 = new cmovI_bso_stackSlotLNode();
 
     // inputs for new nodes
     m1->add_req(n_region);
@@ -9785,7 +9785,7 @@
 
     // operands for new nodes
     m1->_opnds[0] = op_dst;
-    m1->_opnds[1] = new (C) immI16Oper(0);
+    m1->_opnds[1] = new immI16Oper(0);
 
     m2->_opnds[0] = op_dst;
     m2->_opnds[1] = op_crx;
@@ -9942,8 +9942,8 @@
     //
 
     // Create new nodes.
-    MachNode *m1 = new (C) loadConL16Node();
-    MachNode *m2 = new (C) cmovL_bso_stackSlotLNode();
+    MachNode *m1 = new loadConL16Node();
+    MachNode *m2 = new cmovL_bso_stackSlotLNode();
 
     // inputs for new nodes
     m1->add_req(n_region);
@@ -9952,7 +9952,7 @@
 
     // operands for new nodes
     m1->_opnds[0] = op_dst;
-    m1->_opnds[1] = new (C) immL16Oper(0);
+    m1->_opnds[1] = new immL16Oper(0);
     m2->_opnds[0] = op_dst;
     m2->_opnds[1] = op_crx;
     m2->_opnds[2] = op_mem;
@@ -10288,8 +10288,8 @@
     //
 
     // Create new nodes.
-    MachNode *m1 = new (C) loadConI16Node();
-    MachNode *m2 = new (C) cmovI_conIvalueMinus1_conIvalue1Node();
+    MachNode *m1 = new loadConI16Node();
+    MachNode *m2 = new cmovI_conIvalueMinus1_conIvalue1Node();
 
     // inputs for new nodes
     m1->add_req(n_region);
@@ -10298,7 +10298,7 @@
 
     // operands for new nodes
     m1->_opnds[0] = op_dst;
-    m1->_opnds[1] = new (C) immI16Oper(0);
+    m1->_opnds[1] = new immI16Oper(0);
     m2->_opnds[0] = op_dst;
     m2->_opnds[1] = op_crx;
 
@@ -10623,8 +10623,8 @@
     //
 
     // Create new nodes.
-    MachNode *m1 = new (C) cmpFUnordered_reg_regNode();
-    MachNode *m2 = new (C) cmov_bns_lessNode();
+    MachNode *m1 = new cmpFUnordered_reg_regNode();
+    MachNode *m2 = new cmov_bns_lessNode();
 
     // inputs for new nodes
     m1->add_req(n_region, n_src1, n_src2);
@@ -10698,8 +10698,8 @@
     //
 
     // create new nodes
-    MachNode *m1 = new (C) cmpDUnordered_reg_regNode();
-    MachNode *m2 = new (C) cmov_bns_lessNode();
+    MachNode *m1 = new cmpDUnordered_reg_regNode();
+    MachNode *m2 = new cmov_bns_lessNode();
 
     // inputs for new nodes
     m1->add_req(n_region, n_src1, n_src2);
--- a/src/cpu/sparc/vm/assembler_sparc.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/assembler_sparc.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -123,6 +123,7 @@
     fpop2_op3    = 0x35,
     impdep1_op3  = 0x36,
     aes3_op3     = 0x36,
+    sha_op3      = 0x36,
     alignaddr_op3  = 0x36,
     faligndata_op3 = 0x36,
     flog3_op3    = 0x36,
@@ -223,7 +224,11 @@
     mwtos_opf          = 0x119,
 
     aes_kexpand0_opf   = 0x130,
-    aes_kexpand2_opf   = 0x131
+    aes_kexpand2_opf   = 0x131,
+
+    sha1_opf           = 0x141,
+    sha256_opf         = 0x142,
+    sha512_opf         = 0x143
   };
 
   enum op5s {
@@ -595,6 +600,11 @@
   // AES crypto instructions supported only on certain processors
   static void aes_only() { assert( VM_Version::has_aes(), "This instruction only works on SPARC with AES instructions support"); }
 
+  // SHA crypto instructions supported only on certain processors
+  static void sha1_only()   { assert( VM_Version::has_sha1(),   "This instruction only works on SPARC with SHA1"); }
+  static void sha256_only() { assert( VM_Version::has_sha256(), "This instruction only works on SPARC with SHA256"); }
+  static void sha512_only() { assert( VM_Version::has_sha512(), "This instruction only works on SPARC with SHA512"); }
+
   // instruction only in VIS1
   static void vis1_only() { assert( VM_Version::has_vis1(), "This instruction only works on SPARC with VIS1"); }
 
@@ -1179,7 +1189,6 @@
                                                u_field(3, 29, 25) | immed(true) | simm(simm13a, 13)); }
   inline void wrfprs( Register d) { v9_only(); emit_int32( op(arith_op) | rs1(d) | op3(wrreg_op3) | u_field(6, 29, 25)); }
 
-
   //  VIS1 instructions
 
   void alignaddr( Register s1, Register s2, Register d ) { vis1_only(); emit_int32( op(arith_op) | rd(d) | op3(alignaddr_op3) | rs1(s1) | opf(alignaddr_opf) | rs2(s2)); }
@@ -1203,6 +1212,12 @@
   void movwtos( Register s, FloatRegister d ) { vis3_only();  emit_int32( op(arith_op) | fd(d, FloatRegisterImpl::S) | op3(mftoi_op3) | opf(mwtos_opf) | rs2(s)); }
   void movxtod( Register s, FloatRegister d ) { vis3_only();  emit_int32( op(arith_op) | fd(d, FloatRegisterImpl::D) | op3(mftoi_op3) | opf(mxtod_opf) | rs2(s)); }
 
+  // Crypto SHA instructions
+
+  void sha1()   { sha1_only();    emit_int32( op(arith_op) | op3(sha_op3) | opf(sha1_opf)); }
+  void sha256() { sha256_only();  emit_int32( op(arith_op) | op3(sha_op3) | opf(sha256_opf)); }
+  void sha512() { sha512_only();  emit_int32( op(arith_op) | op3(sha_op3) | opf(sha512_opf)); }
+
   // Creation
   Assembler(CodeBuffer* code) : AbstractAssembler(code) {
 #ifdef CHECK_DELAY
--- a/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1612,13 +1612,10 @@
   __ set((intptr_t)os::get_polling_page(), tmp->as_register());
   if (info != NULL) {
     add_debug_info_for_branch(info);
-  } else {
-    __ relocate(relocInfo::poll_type);
   }
-
   int offset = __ offset();
+  __ relocate(relocInfo::poll_type);
   __ ld_ptr(tmp->as_register(), 0, G0);
-
   return offset;
 }
 
--- a/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -872,21 +872,19 @@
 
 
 void LIRGenerator::do_NewInstance(NewInstance* x) {
+  print_if_not_loaded(x);
+
   // This instruction can be deoptimized in the slow path : use
   // O0 as result register.
   const LIR_Opr reg = result_register_for(x->type());
-#ifndef PRODUCT
-  if (PrintNotLoaded && !x->klass()->is_loaded()) {
-    tty->print_cr("   ###class not loaded at new bci %d", x->printable_bci());
-  }
-#endif
+
   CodeEmitInfo* info = state_for(x, x->state());
   LIR_Opr tmp1 = FrameMap::G1_oop_opr;
   LIR_Opr tmp2 = FrameMap::G3_oop_opr;
   LIR_Opr tmp3 = FrameMap::G4_oop_opr;
   LIR_Opr tmp4 = FrameMap::O1_oop_opr;
   LIR_Opr klass_reg = FrameMap::G5_metadata_opr;
-  new_instance(reg, x->klass(), tmp1, tmp2, tmp3, tmp4, klass_reg, info);
+  new_instance(reg, x->klass(), x->is_unresolved(), tmp1, tmp2, tmp3, tmp4, klass_reg, info);
   LIR_Opr result = rlock_result(x);
   __ move(reg, result);
 }
--- a/src/cpu/sparc/vm/compiledIC_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/compiledIC_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -135,7 +135,7 @@
   if (TraceICs) {
     ResourceMark rm;
     tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_interpreted %s",
-                  instruction_address(),
+                  p2i(instruction_address()),
                   callee->name_and_sig_as_C_string());
   }
 
--- a/src/cpu/sparc/vm/debug_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/debug_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -42,20 +42,24 @@
   intptr_t *pc = NULL;
   intptr_t *next_pc = NULL;
   int count = 0;
-  tty->print("register window backtrace from %#x:\n", sp);
+  tty->print_cr("register window backtrace from " INTPTR_FORMAT ":", p2i(sp));
   while (sp != NULL && ((intptr_t)sp & 7) == 0 && sp > prev_sp && sp < prev_sp+1000) {
     pc      = next_pc;
     next_pc = (intptr_t*) sp[I7->sp_offset_in_saved_window()];
-    tty->print("[%d] sp=%#x pc=", count, sp);
+    tty->print("[%d] sp=" INTPTR_FORMAT " pc=", count, p2i(sp));
     findpc((intptr_t)pc);
     if (WizardMode && Verbose) {
       // print register window contents also
-      tty->print_cr("    L0..L7: {%#x %#x %#x %#x %#x %#x %#x %#x}",
-                    sp[0+0],sp[0+1],sp[0+2],sp[0+3],
-                    sp[0+4],sp[0+5],sp[0+6],sp[0+7]);
-      tty->print_cr("    I0..I7: {%#x %#x %#x %#x %#x %#x %#x %#x}",
-                    sp[8+0],sp[8+1],sp[8+2],sp[8+3],
-                    sp[8+4],sp[8+5],sp[8+6],sp[8+7]);
+      tty->print_cr("    L0..L7: {"
+                    INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " "
+                    INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " ",
+                    sp[0+0], sp[0+1], sp[0+2], sp[0+3],
+                    sp[0+4], sp[0+5], sp[0+6], sp[0+7]);
+      tty->print_cr("    I0..I7: {"
+                    INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " "
+                    INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT " ",
+                    sp[8+0], sp[8+1], sp[8+2], sp[8+3],
+                    sp[8+4], sp[8+5], sp[8+6], sp[8+7]);
       // (and print stack frame contents too??)
 
       CodeBlob *b = CodeCache::find_blob((address) pc);
@@ -74,7 +78,7 @@
     count += 1;
   }
   if (sp != NULL)
-    tty->print("[%d] sp=%#x [bogus sp!]", count, sp);
+    tty->print("[%d] sp=" INTPTR_FORMAT " [bogus sp!]", count, p2i(sp));
 }
 
 #endif // PRODUCT
--- a/src/cpu/sparc/vm/frame_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/frame_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -557,7 +557,8 @@
     // QQQ this assert is invalid (or too strong anyway) sice _pc could
     // be original pc and frame could have the deopt pc.
     // assert(_pc == *O7_addr() + pc_return_offset, "frame has wrong pc");
-    tty->print_cr("patch_pc at address  0x%x [0x%x -> 0x%x] ", O7_addr(), _pc, pc);
+    tty->print_cr("patch_pc at address " INTPTR_FORMAT " [" INTPTR_FORMAT " -> " INTPTR_FORMAT "]",
+                  p2i(O7_addr()), p2i(_pc), p2i(pc));
   }
   _cb = CodeCache::find_blob(pc);
   *O7_addr() = pc - pc_return_offset;
--- a/src/cpu/sparc/vm/macroAssembler_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/macroAssembler_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1202,7 +1202,7 @@
     if ( j != last )  s->print(" - f%d", last);
     s->print(" = %f", val);
     s->fill_to(25);
-    s->print_cr(" (0x%x)", val);
+    s->print_cr(" (0x%x)", *(int*)&val);
     j = last + 1;
   }
   s->cr();
--- a/src/cpu/sparc/vm/methodHandles_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/methodHandles_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -483,7 +483,7 @@
   const char* mh_reg_name = has_mh ? "G3_mh" : "G3";
   tty->print_cr("MH %s %s="INTPTR_FORMAT " saved_sp=" INTPTR_FORMAT " args=" INTPTR_FORMAT,
                 adaptername, mh_reg_name,
-                (intptr_t) mh, saved_sp, args);
+                p2i(mh), p2i(saved_sp), p2i(args));
 
   if (Verbose) {
     // dumping last frame with frame::describe
--- a/src/cpu/sparc/vm/nativeInst_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/nativeInst_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -78,7 +78,7 @@
 }
 
 void NativeInstruction::print() {
-  tty->print_cr(INTPTR_FORMAT ": 0x%x", addr_at(0), long_at(0));
+  tty->print_cr(INTPTR_FORMAT ": 0x%x", p2i(addr_at(0)), long_at(0));
 }
 
 void NativeInstruction::set_long_at(int offset, int i) {
@@ -142,7 +142,7 @@
 }
 
 void NativeCall::print() {
-  tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, instruction_address(), destination());
+  tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, p2i(instruction_address()), p2i(destination()));
 }
 
 
@@ -271,7 +271,7 @@
 }
 
 void NativeFarCall::print() {
-  tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, instruction_address(), destination());
+  tty->print_cr(INTPTR_FORMAT ": call " INTPTR_FORMAT, p2i(instruction_address()), p2i(destination()));
 }
 
 bool NativeFarCall::destination_is_compiled_verified_entry_point() {
@@ -324,7 +324,7 @@
 
 
 void NativeMovConstReg::print() {
-  tty->print_cr(INTPTR_FORMAT ": mov reg, " INTPTR_FORMAT, instruction_address(), data());
+  tty->print_cr(INTPTR_FORMAT ": mov reg, " INTPTR_FORMAT, p2i(instruction_address()), data());
 }
 
 
@@ -446,7 +446,7 @@
 
 
 void NativeMovConstRegPatching::print() {
-  tty->print_cr(INTPTR_FORMAT ": mov reg, " INTPTR_FORMAT, instruction_address(), data());
+  tty->print_cr(INTPTR_FORMAT ": mov reg, 0x%x", p2i(instruction_address()), data());
 }
 
 
@@ -585,9 +585,10 @@
 
 void NativeMovRegMem::print() {
   if (is_immediate()) {
-    tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + %x]", instruction_address(), offset());
+    // offset is a signed 13-bit immediate, so casting it to int will not lose significant bits
+    tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + %d]", p2i(instruction_address()), (int)offset());
   } else {
-    tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + reg]", instruction_address());
+    tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + reg]", p2i(instruction_address()));
   }
 }
 
@@ -689,149 +690,6 @@
 
 // End code for unit testing implementation of NativeMovRegMem class
 
-//--------------------------------------------------------------------------------
-
-
-void NativeMovRegMemPatching::copy_instruction_to(address new_instruction_address) {
-  Untested("copy_instruction_to");
-  int instruction_size = next_instruction_address() - instruction_address();
-  for (int i = 0; i < instruction_size; i += wordSize) {
-    *(long*)(new_instruction_address + i) = *(long*)(address(this) + i);
-  }
-}
-
-
-void NativeMovRegMemPatching::verify() {
-  NativeInstruction::verify();
-  // make sure code pattern is actually a "ld" or "st" of some sort.
-  int i0 = long_at(0);
-  int op3 = inv_op3(i0);
-
-  assert((int)nop_offset == (int)NativeMovConstReg::add_offset, "sethi size ok");
-
-  if (!(is_op(i0, Assembler::ldst_op) &&
-        inv_immed(i0) &&
-        0 != (op3 < op3_ldst_int_limit
-         ? (1 <<  op3                      ) & (op3_mask_ld  | op3_mask_st)
-         : (1 << (op3 - op3_ldst_int_limit)) & (op3_mask_ldf | op3_mask_stf)))) {
-    int i1 = long_at(ldst_offset);
-    Register rd = inv_rd(i0);
-
-    op3 = inv_op3(i1);
-    if (!is_op(i1, Assembler::ldst_op) && rd == inv_rs2(i1) &&
-         0 != (op3 < op3_ldst_int_limit
-              ? (1 <<  op3                      ) & (op3_mask_ld  | op3_mask_st)
-              : (1 << (op3 - op3_ldst_int_limit)) & (op3_mask_ldf | op3_mask_stf))) {
-      fatal("not a ld* or st* op");
-    }
-  }
-}
-
-
-void NativeMovRegMemPatching::print() {
-  if (is_immediate()) {
-    tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + %x]", instruction_address(), offset());
-  } else {
-    tty->print_cr(INTPTR_FORMAT ": mov reg, [reg + reg]", instruction_address());
-  }
-}
-
-
-// Code for unit testing implementation of NativeMovRegMemPatching class
-void NativeMovRegMemPatching::test() {
-#ifdef ASSERT
-  ResourceMark rm;
-  CodeBuffer cb("test", 1000, 1000);
-  MacroAssembler* a = new MacroAssembler(&cb);
-  NativeMovRegMemPatching* nm;
-  uint idx = 0;
-  uint idx1;
-  int offsets[] = {
-    0x0,
-    0xffffffff,
-    0x7fffffff,
-    0x80000000,
-    4096,
-    4097,
-    0x20,
-    0x4000,
-  };
-
-  VM_Version::allow_all();
-
-  AddressLiteral al(0xffffffff, relocInfo::external_word_type);
-  a->ldsw( G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->ldsw( G5, I3, G4 ); idx++;
-  a->ldsb( G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->ldsb( G5, I3, G4 ); idx++;
-  a->ldsh( G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->ldsh( G5, I3, G4 ); idx++;
-  a->lduw( G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->lduw( G5, I3, G4 ); idx++;
-  a->ldub( G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->ldub( G5, I3, G4 ); idx++;
-  a->lduh( G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->lduh( G5, I3, G4 ); idx++;
-  a->ldx(  G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->ldx(  G5, I3, G4 ); idx++;
-  a->ldd(  G5, al.low10(), G4); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->ldd(  G5, I3, G4 ); idx++;
-  a->ldf(  FloatRegisterImpl::D, O2, -1, F14 ); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->ldf(  FloatRegisterImpl::S, O0, I3, F15 ); idx++;
-
-  a->stw( G5, G4, al.low10()); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->stw( G5, G4, I3 ); idx++;
-  a->stb( G5, G4, al.low10()); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->stb( G5, G4, I3 ); idx++;
-  a->sth( G5, G4, al.low10()); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->sth( G5, G4, I3 ); idx++;
-  a->stx( G5, G4, al.low10()); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->stx( G5, G4, I3 ); idx++;
-  a->std( G5, G4, al.low10()); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->std( G5, G4, I3 ); idx++;
-  a->stf( FloatRegisterImpl::S, F18, O2, -1 ); idx++;
-  a->sethi(al, I3); a->nop(); a->add(I3, al.low10(), I3);
-  a->stf( FloatRegisterImpl::S, F15, O0, I3 ); idx++;
-
-  nm = nativeMovRegMemPatching_at( cb.insts_begin() );
-  nm->print();
-  nm->set_offset( low10(0) );
-  nm->print();
-  nm->add_offset_in_bytes( low10(0xbb) * wordSize );
-  nm->print();
-
-  while (--idx) {
-    nm = nativeMovRegMemPatching_at( nm->next_instruction_address() );
-    nm->print();
-    for (idx1 = 0; idx1 < ARRAY_SIZE(offsets); idx1++) {
-      nm->set_offset( nm->is_immediate() ? low10(offsets[idx1]) : offsets[idx1] );
-      assert(nm->offset() == (nm->is_immediate() ? low10(offsets[idx1]) : offsets[idx1]),
-             "check unit test");
-      nm->print();
-    }
-    nm->add_offset_in_bytes( low10(0xbb) * wordSize );
-    nm->print();
-  }
-
-  VM_Version::revert();
-#endif // ASSERT
-}
-// End code for unit testing implementation of NativeMovRegMemPatching class
-
 
 //--------------------------------------------------------------------------------
 
@@ -863,7 +721,7 @@
 
 
 void NativeJump::print() {
-  tty->print_cr(INTPTR_FORMAT ": jmpl reg, " INTPTR_FORMAT, instruction_address(), jump_destination());
+  tty->print_cr(INTPTR_FORMAT ": jmpl reg, " INTPTR_FORMAT, p2i(instruction_address()), p2i(jump_destination()));
 }
 
 
--- a/src/cpu/sparc/vm/nativeInst_sparc.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/nativeInst_sparc.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -38,7 +38,6 @@
 // - - NativeMovConstReg
 // - - NativeMovConstRegPatching
 // - - NativeMovRegMem
-// - - NativeMovRegMemPatching
 // - - NativeJump
 // - - NativeGeneralJump
 // - - NativeIllegalInstruction
@@ -710,96 +709,6 @@
 };
 
 
-// An interface for accessing/manipulating native memory ops
-//      ld* [reg + offset], reg
-//      st* reg, [reg + offset]
-//      sethi %hi(imm), reg; nop; add reg, %lo(imm), reg; ld* [reg1 + reg], reg2
-//      sethi %hi(imm), reg; nop; add reg, %lo(imm), reg; st* reg2, [reg1 + reg]
-// Ops covered: {lds,ldu,st}{w,b,h}, {ld,st}{d,x}
-//
-// Note that it is identical to NativeMovRegMem with the exception of a nop between the
-// sethi and the add.  The nop is required to be in the delay slot of the call instruction
-// which overwrites the sethi during patching.
-class NativeMovRegMemPatching;
-inline NativeMovRegMemPatching* nativeMovRegMemPatching_at (address address);
-class NativeMovRegMemPatching: public NativeInstruction {
- public:
-  enum Sparc_specific_constants {
-    op3_mask_ld = 1 << Assembler::lduw_op3 |
-                  1 << Assembler::ldub_op3 |
-                  1 << Assembler::lduh_op3 |
-                  1 << Assembler::ldd_op3 |
-                  1 << Assembler::ldsw_op3 |
-                  1 << Assembler::ldsb_op3 |
-                  1 << Assembler::ldsh_op3 |
-                  1 << Assembler::ldx_op3,
-    op3_mask_st = 1 << Assembler::stw_op3 |
-                  1 << Assembler::stb_op3 |
-                  1 << Assembler::sth_op3 |
-                  1 << Assembler::std_op3 |
-                  1 << Assembler::stx_op3,
-    op3_ldst_int_limit = Assembler::ldf_op3,
-    op3_mask_ldf = 1 << (Assembler::ldf_op3  - op3_ldst_int_limit) |
-                   1 << (Assembler::lddf_op3 - op3_ldst_int_limit),
-    op3_mask_stf = 1 << (Assembler::stf_op3  - op3_ldst_int_limit) |
-                   1 << (Assembler::stdf_op3 - op3_ldst_int_limit),
-
-    offset_width    = 13,
-    sethi_offset    = 0,
-#ifdef _LP64
-    nop_offset      = 7 * BytesPerInstWord,
-#else
-    nop_offset      = 4,
-#endif
-    add_offset      = nop_offset + BytesPerInstWord,
-    ldst_offset     = add_offset + BytesPerInstWord
-  };
-  bool is_immediate() const {
-    // check if instruction is ld* [reg + offset], reg or st* reg, [reg + offset]
-    int i0 = long_at(0);
-    return (is_op(i0, Assembler::ldst_op));
-  }
-
-  address instruction_address() const           { return addr_at(0); }
-  address next_instruction_address() const      {
-    return addr_at(is_immediate()? 4 : 16);
-  }
-  int   offset() const                          {
-     return is_immediate()? inv_simm(long_at(0), offset_width) :
-                            nativeMovConstRegPatching_at(addr_at(0))->data();
-  }
-  void  set_offset(int x) {
-    if (is_immediate()) {
-      guarantee(fits_in_simm(x, offset_width), "data block offset overflow");
-      set_long_at(0, set_simm(long_at(0), x, offset_width));
-    }
-    else
-      nativeMovConstRegPatching_at(addr_at(0))->set_data(x);
-  }
-
-  void  add_offset_in_bytes(intptr_t radd_offset)     {
-      set_offset (offset() + radd_offset);
-  }
-
-  void  copy_instruction_to(address new_instruction_address);
-
-  void verify();
-  void print ();
-
-  // unit test stuff
-  static void test();
-
- private:
-  friend inline NativeMovRegMemPatching* nativeMovRegMemPatching_at (address address) {
-    NativeMovRegMemPatching* test = (NativeMovRegMemPatching*)address;
-    #ifdef ASSERT
-      test->verify();
-    #endif
-    return test;
-  }
-};
-
-
 // An interface for accessing/manipulating native jumps
 //      jump_to addr
 //      == sethi %hi22(addr), temp ;  jumpl reg, %lo10(addr), G0 ;  <delay>
--- a/src/cpu/sparc/vm/sparc.ad	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/sparc.ad	Fri Jun 20 10:15:08 2014 -0700
@@ -1206,10 +1206,10 @@
   }
 
   if (Assembler::is_simm13(-framesize)) {
-    st->print   ("SAVE   R_SP,-%d,R_SP",framesize);
+    st->print   ("SAVE   R_SP,-" SIZE_FORMAT ",R_SP",framesize);
   } else {
-    st->print_cr("SETHI  R_SP,hi%%(-%d),R_G3",framesize); st->print("\t");
-    st->print_cr("ADD    R_G3,lo%%(-%d),R_G3",framesize); st->print("\t");
+    st->print_cr("SETHI  R_SP,hi%%(-" SIZE_FORMAT "),R_G3",framesize); st->print("\t");
+    st->print_cr("ADD    R_G3,lo%%(-" SIZE_FORMAT "),R_G3",framesize); st->print("\t");
     st->print   ("SAVE   R_SP,R_G3,R_SP");
   }
 
--- a/src/cpu/sparc/vm/stubGenerator_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/stubGenerator_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -4575,6 +4575,219 @@
     return start;
   }
 
+  address generate_sha1_implCompress(bool multi_block, const char *name) {
+    __ align(CodeEntryAlignment);
+    StubCodeMark mark(this, "StubRoutines", name);
+    address start = __ pc();
+
+    Label L_sha1_loop, L_sha1_unaligned_input, L_sha1_unaligned_input_loop;
+    int i;
+
+    Register buf   = O0; // byte[] source+offset
+    Register state = O1; // int[]  SHA.state
+    Register ofs   = O2; // int    offset
+    Register limit = O3; // int    limit
+
+    // load state into F0-F4
+    for (i = 0; i < 5; i++) {
+      __ ldf(FloatRegisterImpl::S, state, i*4, as_FloatRegister(i));
+    }
+
+    __ andcc(buf, 7, G0);
+    __ br(Assembler::notZero, false, Assembler::pn, L_sha1_unaligned_input);
+    __ delayed()->nop();
+
+    __ BIND(L_sha1_loop);
+    // load buf into F8-F22
+    for (i = 0; i < 8; i++) {
+      __ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
+    }
+    __ sha1();
+    if (multi_block) {
+      __ add(ofs, 64, ofs);
+      __ add(buf, 64, buf);
+      __ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha1_loop);
+      __ mov(ofs, O0); // to be returned
+    }
+
+    // store F0-F4 into state and return
+    for (i = 0; i < 4; i++) {
+      __ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
+    }
+    __ retl();
+    __ delayed()->stf(FloatRegisterImpl::S, F4, state, 0x10);
+
+    __ BIND(L_sha1_unaligned_input);
+    __ alignaddr(buf, G0, buf);
+
+    __ BIND(L_sha1_unaligned_input_loop);
+    // load buf into F8-F22
+    for (i = 0; i < 9; i++) {
+      __ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
+    }
+    for (i = 0; i < 8; i++) {
+      __ faligndata(as_FloatRegister(i*2 + 8), as_FloatRegister(i*2 + 10), as_FloatRegister(i*2 + 8));
+    }
+    __ sha1();
+    if (multi_block) {
+      __ add(ofs, 64, ofs);
+      __ add(buf, 64, buf);
+      __ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha1_unaligned_input_loop);
+      __ mov(ofs, O0); // to be returned
+    }
+
+    // store F0-F4 into state and return
+    for (i = 0; i < 4; i++) {
+      __ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
+    }
+    __ retl();
+    __ delayed()->stf(FloatRegisterImpl::S, F4, state, 0x10);
+
+    return start;
+  }
+
+  address generate_sha256_implCompress(bool multi_block, const char *name) {
+    __ align(CodeEntryAlignment);
+    StubCodeMark mark(this, "StubRoutines", name);
+    address start = __ pc();
+
+    Label L_sha256_loop, L_sha256_unaligned_input, L_sha256_unaligned_input_loop;
+    int i;
+
+    Register buf   = O0; // byte[] source+offset
+    Register state = O1; // int[]  SHA2.state
+    Register ofs   = O2; // int    offset
+    Register limit = O3; // int    limit
+
+    // load state into F0-F7
+    for (i = 0; i < 8; i++) {
+      __ ldf(FloatRegisterImpl::S, state, i*4, as_FloatRegister(i));
+    }
+
+    __ andcc(buf, 7, G0);
+    __ br(Assembler::notZero, false, Assembler::pn, L_sha256_unaligned_input);
+    __ delayed()->nop();
+
+    __ BIND(L_sha256_loop);
+    // load buf into F8-F22
+    for (i = 0; i < 8; i++) {
+      __ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
+    }
+    __ sha256();
+    if (multi_block) {
+      __ add(ofs, 64, ofs);
+      __ add(buf, 64, buf);
+      __ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha256_loop);
+      __ mov(ofs, O0); // to be returned
+    }
+
+    // store F0-F7 into state and return
+    for (i = 0; i < 7; i++) {
+      __ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
+    }
+    __ retl();
+    __ delayed()->stf(FloatRegisterImpl::S, F7, state, 0x1c);
+
+    __ BIND(L_sha256_unaligned_input);
+    __ alignaddr(buf, G0, buf);
+
+    __ BIND(L_sha256_unaligned_input_loop);
+    // load buf into F8-F22
+    for (i = 0; i < 9; i++) {
+      __ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 8));
+    }
+    for (i = 0; i < 8; i++) {
+      __ faligndata(as_FloatRegister(i*2 + 8), as_FloatRegister(i*2 + 10), as_FloatRegister(i*2 + 8));
+    }
+    __ sha256();
+    if (multi_block) {
+      __ add(ofs, 64, ofs);
+      __ add(buf, 64, buf);
+      __ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha256_unaligned_input_loop);
+      __ mov(ofs, O0); // to be returned
+    }
+
+    // store F0-F7 into state and return
+    for (i = 0; i < 7; i++) {
+      __ stf(FloatRegisterImpl::S, as_FloatRegister(i), state, i*4);
+    }
+    __ retl();
+    __ delayed()->stf(FloatRegisterImpl::S, F7, state, 0x1c);
+
+    return start;
+  }
+
+  address generate_sha512_implCompress(bool multi_block, const char *name) {
+    __ align(CodeEntryAlignment);
+    StubCodeMark mark(this, "StubRoutines", name);
+    address start = __ pc();
+
+    Label L_sha512_loop, L_sha512_unaligned_input, L_sha512_unaligned_input_loop;
+    int i;
+
+    Register buf   = O0; // byte[] source+offset
+    Register state = O1; // long[] SHA5.state
+    Register ofs   = O2; // int    offset
+    Register limit = O3; // int    limit
+
+    // load state into F0-F14
+    for (i = 0; i < 8; i++) {
+      __ ldf(FloatRegisterImpl::D, state, i*8, as_FloatRegister(i*2));
+    }
+
+    __ andcc(buf, 7, G0);
+    __ br(Assembler::notZero, false, Assembler::pn, L_sha512_unaligned_input);
+    __ delayed()->nop();
+
+    __ BIND(L_sha512_loop);
+    // load buf into F16-F46
+    for (i = 0; i < 16; i++) {
+      __ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 16));
+    }
+    __ sha512();
+    if (multi_block) {
+      __ add(ofs, 128, ofs);
+      __ add(buf, 128, buf);
+      __ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha512_loop);
+      __ mov(ofs, O0); // to be returned
+    }
+
+    // store F0-F14 into state and return
+    for (i = 0; i < 7; i++) {
+      __ stf(FloatRegisterImpl::D, as_FloatRegister(i*2), state, i*8);
+    }
+    __ retl();
+    __ delayed()->stf(FloatRegisterImpl::D, F14, state, 0x38);
+
+    __ BIND(L_sha512_unaligned_input);
+    __ alignaddr(buf, G0, buf);
+
+    __ BIND(L_sha512_unaligned_input_loop);
+    // load buf into F16-F46
+    for (i = 0; i < 17; i++) {
+      __ ldf(FloatRegisterImpl::D, buf, i*8, as_FloatRegister(i*2 + 16));
+    }
+    for (i = 0; i < 16; i++) {
+      __ faligndata(as_FloatRegister(i*2 + 16), as_FloatRegister(i*2 + 18), as_FloatRegister(i*2 + 16));
+    }
+    __ sha512();
+    if (multi_block) {
+      __ add(ofs, 128, ofs);
+      __ add(buf, 128, buf);
+      __ cmp_and_brx_short(ofs, limit, Assembler::lessEqual, Assembler::pt, L_sha512_unaligned_input_loop);
+      __ mov(ofs, O0); // to be returned
+    }
+
+    // store F0-F14 into state and return
+    for (i = 0; i < 7; i++) {
+      __ stf(FloatRegisterImpl::D, as_FloatRegister(i*2), state, i*8);
+    }
+    __ retl();
+    __ delayed()->stf(FloatRegisterImpl::D, F14, state, 0x38);
+
+    return start;
+  }
+
   void generate_initial() {
     // Generates all stubs and initializes the entry points
 
@@ -4647,6 +4860,20 @@
       StubRoutines::_cipherBlockChaining_encryptAESCrypt = generate_cipherBlockChaining_encryptAESCrypt();
       StubRoutines::_cipherBlockChaining_decryptAESCrypt = generate_cipherBlockChaining_decryptAESCrypt_Parallel();
     }
+
+    // generate SHA1/SHA256/SHA512 intrinsics code
+    if (UseSHA1Intrinsics) {
+      StubRoutines::_sha1_implCompress     = generate_sha1_implCompress(false,   "sha1_implCompress");
+      StubRoutines::_sha1_implCompressMB   = generate_sha1_implCompress(true,    "sha1_implCompressMB");
+    }
+    if (UseSHA256Intrinsics) {
+      StubRoutines::_sha256_implCompress   = generate_sha256_implCompress(false, "sha256_implCompress");
+      StubRoutines::_sha256_implCompressMB = generate_sha256_implCompress(true,  "sha256_implCompressMB");
+    }
+    if (UseSHA512Intrinsics) {
+      StubRoutines::_sha512_implCompress   = generate_sha512_implCompress(false, "sha512_implCompress");
+      StubRoutines::_sha512_implCompressMB = generate_sha512_implCompress(true,  "sha512_implCompressMB");
+    }
   }
 
 
--- a/src/cpu/sparc/vm/stubRoutines_sparc.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/stubRoutines_sparc.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -41,7 +41,7 @@
 enum /* platform_dependent_constants */ {
   // %%%%%%%% May be able to shrink this a lot
   code_size1 = 20000,           // simply increase if too small (assembler will crash if too small)
-  code_size2 = 22000            // simply increase if too small (assembler will crash if too small)
+  code_size2 = 23000            // simply increase if too small (assembler will crash if too small)
 };
 
 class Sparc {
--- a/src/cpu/sparc/vm/templateInterpreter_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/templateInterpreter_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1722,15 +1722,15 @@
     if (caller->is_interpreted_frame()) {
       tty->print("interpreted ");
     }
-    tty->print_cr("caller fp=0x%x sp=0x%x", caller->fp(), caller->sp());
-    tty->print_cr("save area = 0x%x, 0x%x", caller->sp(), caller->sp() + 16);
-    tty->print_cr("save area = 0x%x, 0x%x", caller->fp(), caller->fp() + 16);
-    tty->print_cr("interpreter fp=0x%x sp=0x%x", interpreter_frame->fp(), interpreter_frame->sp());
-    tty->print_cr("save area = 0x%x, 0x%x", interpreter_frame->sp(), interpreter_frame->sp() + 16);
-    tty->print_cr("save area = 0x%x, 0x%x", interpreter_frame->fp(), interpreter_frame->fp() + 16);
-    tty->print_cr("Llocals = 0x%x", locals);
-    tty->print_cr("Lesp = 0x%x", esp);
-    tty->print_cr("Lmonitors = 0x%x", monitors);
+    tty->print_cr("caller fp=" INTPTR_FORMAT " sp=" INTPTR_FORMAT, p2i(caller->fp()), p2i(caller->sp()));
+    tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(caller->sp()), p2i(caller->sp() + 16));
+    tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(caller->fp()), p2i(caller->fp() + 16));
+    tty->print_cr("interpreter fp=" INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(interpreter_frame->fp()), p2i(interpreter_frame->sp()));
+    tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(interpreter_frame->sp()), p2i(interpreter_frame->sp() + 16));
+    tty->print_cr("save area = " INTPTR_FORMAT ", " INTPTR_FORMAT, p2i(interpreter_frame->fp()), p2i(interpreter_frame->fp() + 16));
+    tty->print_cr("Llocals = " INTPTR_FORMAT, p2i(locals));
+    tty->print_cr("Lesp = " INTPTR_FORMAT, p2i(esp));
+    tty->print_cr("Lmonitors = " INTPTR_FORMAT, p2i(monitors));
   }
 
   if (method->max_locals() > 0) {
--- a/src/cpu/sparc/vm/vm_version_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/vm_version_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -234,7 +234,7 @@
   assert((OptoLoopAlignment % relocInfo::addr_unit()) == 0, "alignment is not a multiple of NOP size");
 
   char buf[512];
-  jio_snprintf(buf, sizeof(buf), "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
+  jio_snprintf(buf, sizeof(buf), "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
                (has_v9() ? ", v9" : (has_v8() ? ", v8" : "")),
                (has_hardware_popc() ? ", popc" : ""),
                (has_vis1() ? ", vis1" : ""),
@@ -243,6 +243,9 @@
                (has_blk_init() ? ", blk_init" : ""),
                (has_cbcond() ? ", cbcond" : ""),
                (has_aes() ? ", aes" : ""),
+               (has_sha1() ? ", sha1" : ""),
+               (has_sha256() ? ", sha256" : ""),
+               (has_sha512() ? ", sha512" : ""),
                (is_ultra3() ? ", ultra3" : ""),
                (is_sun4v() ? ", sun4v" : ""),
                (is_niagara_plus() ? ", niagara_plus" : (is_niagara() ? ", niagara" : "")),
@@ -301,6 +304,58 @@
     }
   }
 
+  // SHA1, SHA256, and SHA512 instructions were added to SPARC T-series at different times
+  if (has_sha1() || has_sha256() || has_sha512()) {
+    if (UseVIS > 0) { // SHA intrinsics use VIS1 instructions
+      if (FLAG_IS_DEFAULT(UseSHA)) {
+        FLAG_SET_DEFAULT(UseSHA, true);
+      }
+    } else {
+      if (UseSHA) {
+        warning("SPARC SHA intrinsics require VIS1 instruction support. Intrinsics will be disabled.");
+        FLAG_SET_DEFAULT(UseSHA, false);
+      }
+    }
+  } else if (UseSHA) {
+    warning("SHA instructions are not available on this CPU");
+    FLAG_SET_DEFAULT(UseSHA, false);
+  }
+
+  if (!UseSHA) {
+    FLAG_SET_DEFAULT(UseSHA1Intrinsics, false);
+    FLAG_SET_DEFAULT(UseSHA256Intrinsics, false);
+    FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);
+  } else {
+    if (has_sha1()) {
+      if (FLAG_IS_DEFAULT(UseSHA1Intrinsics)) {
+        FLAG_SET_DEFAULT(UseSHA1Intrinsics, true);
+      }
+    } else if (UseSHA1Intrinsics) {
+      warning("SHA1 instruction is not available on this CPU.");
+      FLAG_SET_DEFAULT(UseSHA1Intrinsics, false);
+    }
+    if (has_sha256()) {
+      if (FLAG_IS_DEFAULT(UseSHA256Intrinsics)) {
+        FLAG_SET_DEFAULT(UseSHA256Intrinsics, true);
+      }
+    } else if (UseSHA256Intrinsics) {
+      warning("SHA256 instruction (for SHA-224 and SHA-256) is not available on this CPU.");
+      FLAG_SET_DEFAULT(UseSHA256Intrinsics, false);
+    }
+
+    if (has_sha512()) {
+      if (FLAG_IS_DEFAULT(UseSHA512Intrinsics)) {
+        FLAG_SET_DEFAULT(UseSHA512Intrinsics, true);
+      }
+    } else if (UseSHA512Intrinsics) {
+      warning("SHA512 instruction (for SHA-384 and SHA-512) is not available on this CPU.");
+      FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);
+    }
+    if (!(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics)) {
+      FLAG_SET_DEFAULT(UseSHA, false);
+    }
+  }
+
   if (FLAG_IS_DEFAULT(ContendedPaddingWidth) &&
     (cache_line_size > ContendedPaddingWidth))
     ContendedPaddingWidth = cache_line_size;
--- a/src/cpu/sparc/vm/vm_version_sparc.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/vm_version_sparc.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -50,7 +50,10 @@
     T_family             = 16,
     T1_model             = 17,
     sparc5_instructions  = 18,
-    aes_instructions     = 19
+    aes_instructions     = 19,
+    sha1_instruction     = 20,
+    sha256_instruction   = 21,
+    sha512_instruction   = 22
   };
 
   enum Feature_Flag_Set {
@@ -77,6 +80,9 @@
     T1_model_m              = 1 << T1_model,
     sparc5_instructions_m   = 1 << sparc5_instructions,
     aes_instructions_m      = 1 << aes_instructions,
+    sha1_instruction_m      = 1 << sha1_instruction,
+    sha256_instruction_m    = 1 << sha256_instruction,
+    sha512_instruction_m    = 1 << sha512_instruction,
 
     generic_v8_m        = v8_instructions_m | hardware_mul32_m | hardware_div32_m | hardware_fsmuld_m,
     generic_v9_m        = generic_v8_m | v9_instructions_m,
@@ -129,6 +135,9 @@
   static bool has_cbcond()              { return (_features & cbcond_instructions_m) != 0; }
   static bool has_sparc5_instr()        { return (_features & sparc5_instructions_m) != 0; }
   static bool has_aes()                 { return (_features & aes_instructions_m) != 0; }
+  static bool has_sha1()                { return (_features & sha1_instruction_m) != 0; }
+  static bool has_sha256()              { return (_features & sha256_instruction_m) != 0; }
+  static bool has_sha512()              { return (_features & sha512_instruction_m) != 0; }
 
   static bool supports_compare_and_exchange()
                                         { return has_v9(); }
--- a/src/cpu/sparc/vm/vtableStubs_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/sparc/vm/vtableStubs_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -111,7 +111,7 @@
 
   if (PrintMiscellaneous && (WizardMode || Verbose)) {
     tty->print_cr("vtable #%d at "PTR_FORMAT"[%d] left over: %d",
-                  vtable_index, s->entry_point(),
+                  vtable_index, p2i(s->entry_point()),
                   (int)(s->code_end() - s->entry_point()),
                   (int)(s->code_end() - __ pc()));
   }
@@ -206,7 +206,7 @@
 
   if (PrintMiscellaneous && (WizardMode || Verbose)) {
     tty->print_cr("itable #%d at "PTR_FORMAT"[%d] left over: %d",
-                  itable_index, s->entry_point(),
+                  itable_index, p2i(s->entry_point()),
                   (int)(s->code_end() - s->entry_point()),
                   (int)(s->code_end() - __ pc()));
   }
--- a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1085,14 +1085,11 @@
 
 
 void LIRGenerator::do_NewInstance(NewInstance* x) {
-#ifndef PRODUCT
-  if (PrintNotLoaded && !x->klass()->is_loaded()) {
-    tty->print_cr("   ###class not loaded at new bci %d", x->printable_bci());
-  }
-#endif
+  print_if_not_loaded(x);
+
   CodeEmitInfo* info = state_for(x, x->state());
   LIR_Opr reg = result_register_for(x->type());
-  new_instance(reg, x->klass(),
+  new_instance(reg, x->klass(), x->is_unresolved(),
                        FrameMap::rcx_oop_opr,
                        FrameMap::rdi_oop_opr,
                        FrameMap::rsi_oop_opr,
--- a/src/cpu/x86/vm/nativeInst_x86.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/x86/vm/nativeInst_x86.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -327,18 +327,6 @@
   return test;
 }
 
-class NativeMovRegMemPatching: public NativeMovRegMem {
- private:
-  friend NativeMovRegMemPatching* nativeMovRegMemPatching_at (address address) {
-    NativeMovRegMemPatching* test = (NativeMovRegMemPatching*)(address - instruction_offset);
-    #ifdef ASSERT
-      test->verify();
-    #endif
-    return test;
-  }
-};
-
-
 
 // An interface for accessing/manipulating native leal instruction of form:
 //        leal reg, [reg + offset]
--- a/src/cpu/x86/vm/vm_version_x86.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/x86/vm/vm_version_x86.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -590,6 +590,17 @@
     FLAG_SET_DEFAULT(UseAESIntrinsics, false);
   }
 
+  if (UseSHA) {
+    warning("SHA instructions are not available on this CPU");
+    FLAG_SET_DEFAULT(UseSHA, false);
+  }
+  if (UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics) {
+    warning("SHA intrinsics are not available on this CPU");
+    FLAG_SET_DEFAULT(UseSHA1Intrinsics, false);
+    FLAG_SET_DEFAULT(UseSHA256Intrinsics, false);
+    FLAG_SET_DEFAULT(UseSHA512Intrinsics, false);
+  }
+
   // Adjust RTM (Restricted Transactional Memory) flags
   if (!supports_rtm() && UseRTMLocking) {
     // Can't continue because UseRTMLocking affects UseBiasedLocking flag
--- a/src/cpu/x86/vm/x86_32.ad	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/cpu/x86/vm/x86_32.ad	Fri Jun 20 10:15:08 2014 -0700
@@ -1401,22 +1401,22 @@
     // No transformation necessary.
     return;
   case INDIRECT:
-    new_memory = new (C) indirect_win95_safeOper( );
+    new_memory = new indirect_win95_safeOper( );
     break;
   case INDOFFSET8:
-    new_memory = new (C) indOffset8_win95_safeOper(memory->disp(NULL, NULL, 0));
+    new_memory = new indOffset8_win95_safeOper(memory->disp(NULL, NULL, 0));
     break;
   case INDOFFSET32:
-    new_memory = new (C) indOffset32_win95_safeOper(memory->disp(NULL, NULL, 0));
+    new_memory = new indOffset32_win95_safeOper(memory->disp(NULL, NULL, 0));
     break;
   case INDINDEXOFFSET:
-    new_memory = new (C) indIndexOffset_win95_safeOper(memory->disp(NULL, NULL, 0));
+    new_memory = new indIndexOffset_win95_safeOper(memory->disp(NULL, NULL, 0));
     break;
   case INDINDEXSCALE:
-    new_memory = new (C) indIndexScale_win95_safeOper(memory->scale());
+    new_memory = new indIndexScale_win95_safeOper(memory->scale());
     break;
   case INDINDEXSCALEOFFSET:
-    new_memory = new (C) indIndexScaleOffset_win95_safeOper(memory->scale(), memory->disp(NULL, NULL, 0));
+    new_memory = new indIndexScaleOffset_win95_safeOper(memory->scale(), memory->disp(NULL, NULL, 0));
     break;
   case LOAD_LONG_INDIRECT:
   case LOAD_LONG_INDOFFSET32:
--- a/src/os/aix/vm/os_aix.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/os/aix/vm/os_aix.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -4734,10 +4734,8 @@
   //
   // Thread.interrupt and object.notify{All} both call Event::set.
   // That is, we treat thread.interrupt as a special case of notification.
-  // The underlying Solaris implementation, cond_timedwait, admits
-  // spurious/premature wakeups, but the JLS/JVM spec prevents the
-  // JVM from making those visible to Java code. As such, we must
-  // filter out spurious wakeups. We assume all ETIME returns are valid.
+  // We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
+  // We assume all ETIME returns are valid.
   //
   // TODO: properly differentiate simultaneous notify+interrupt.
   // In that case, we should propagate the notify to another waiter.
--- a/src/os/bsd/vm/os_bsd.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/os/bsd/vm/os_bsd.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -4299,10 +4299,8 @@
   //
   // Thread.interrupt and object.notify{All} both call Event::set.
   // That is, we treat thread.interrupt as a special case of notification.
-  // The underlying Solaris implementation, cond_timedwait, admits
-  // spurious/premature wakeups, but the JLS/JVM spec prevents the
-  // JVM from making those visible to Java code.  As such, we must
-  // filter out spurious wakeups.  We assume all ETIME returns are valid.
+  // We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
+  // We assume all ETIME returns are valid.
   //
   // TODO: properly differentiate simultaneous notify+interrupt.
   // In that case, we should propagate the notify to another waiter.
--- a/src/os/linux/vm/os_linux.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/os/linux/vm/os_linux.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -5538,10 +5538,8 @@
   //
   // Thread.interrupt and object.notify{All} both call Event::set.
   // That is, we treat thread.interrupt as a special case of notification.
-  // The underlying Solaris implementation, cond_timedwait, admits
-  // spurious/premature wakeups, but the JLS/JVM spec prevents the
-  // JVM from making those visible to Java code.  As such, we must
-  // filter out spurious wakeups.  We assume all ETIME returns are valid.
+  // We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
+  // We assume all ETIME returns are valid.
   //
   // TODO: properly differentiate simultaneous notify+interrupt.
   // In that case, we should propagate the notify to another waiter.
--- a/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -234,7 +234,7 @@
                SIG_REGS(sc).u_regs[CON_G3],
                SIG_REGS(sc).u_regs[CON_G4]);
   st->print_cr(" G5=" INTPTR_FORMAT " G6=" INTPTR_FORMAT
-               " G7=" INTPTR_FORMAT " Y=" INTPTR_FORMAT,
+               " G7=" INTPTR_FORMAT " Y=0x%x",
                SIG_REGS(sc).u_regs[CON_G5],
                SIG_REGS(sc).u_regs[CON_G6],
                SIG_REGS(sc).u_regs[CON_G7],
@@ -285,7 +285,7 @@
   st->cr();
   st->cr();
 
-  st->print_cr("Top of Stack: (sp=" PTR_FORMAT ")", sp);
+  st->print_cr("Top of Stack: (sp=" INTPTR_FORMAT ")", p2i(sp));
   print_hex_dump(st, (address)sp, (address)(sp + 32), sizeof(intptr_t));
   st->cr();
 
@@ -293,7 +293,7 @@
   // point to garbage if entry point in an nmethod is corrupted. Leave
   // this at the end, and hope for the best.
   address pc = os::Linux::ucontext_get_pc(uc);
-  st->print_cr("Instructions: (pc=" PTR_FORMAT ")", pc);
+  st->print_cr("Instructions: (pc=" INTPTR_FORMAT ")", p2i(pc));
   print_hex_dump(st, pc - 32, pc + 32, sizeof(char));
 }
 
@@ -453,7 +453,7 @@
       && pc <  MacroAssembler::_verify_oop_implicit_branch[1] ) {
     *stub     =  MacroAssembler::_verify_oop_implicit_branch[2];
     warning("fixed up memory fault in +VerifyOops at address "
-            INTPTR_FORMAT, fault);
+            INTPTR_FORMAT, p2i(fault));
     return true;
   }
   return false;
--- a/src/os_cpu/linux_sparc/vm/vm_version_linux_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/os_cpu/linux_sparc/vm/vm_version_linux_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -36,7 +36,7 @@
   }
 
   while (!feof(fp)) {
-    if (fscanf(fp, "cpu\t\t: %100[^\n]", &cpu) == 1) {
+    if (fscanf(fp, "cpu\t\t: %100[^\n]", cpu) == 1) {
       if (strstr(cpu, "Niagara") != NULL) {
         rv = true;
       }
--- a/src/os_cpu/solaris_sparc/vm/vm_version_solaris_sparc.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/os_cpu/solaris_sparc/vm/vm_version_solaris_sparc.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -137,6 +137,21 @@
 #endif
     if (av & AV_SPARC_AES)       features |= aes_instructions_m;
 
+#ifndef AV_SPARC_SHA1
+#define AV_SPARC_SHA1   0x00400000  /* sha1 instruction supported */
+#endif
+    if (av & AV_SPARC_SHA1)         features |= sha1_instruction_m;
+
+#ifndef AV_SPARC_SHA256
+#define AV_SPARC_SHA256 0x00800000  /* sha256 instruction supported */
+#endif
+    if (av & AV_SPARC_SHA256)       features |= sha256_instruction_m;
+
+#ifndef AV_SPARC_SHA512
+#define AV_SPARC_SHA512 0x01000000  /* sha512 instruction supported */
+#endif
+    if (av & AV_SPARC_SHA512)       features |= sha512_instruction_m;
+
   } else {
     // getisax(2) failed, use the old legacy code.
 #ifndef PRODUCT
--- a/src/share/vm/adlc/output_c.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/adlc/output_c.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1000,7 +1000,7 @@
   fprintf(fp_cpp, "void Bundle::initialize_nops(MachNode * nop_list[%d], Compile *C) {\n", nopcnt);
   int i = 0;
   for ( _pipeline->_noplist.reset(); (nop = _pipeline->_noplist.iter()) != NULL; i++ ) {
-    fprintf(fp_cpp, "  nop_list[%d] = (MachNode *) new (C) %sNode();\n", i, nop);
+    fprintf(fp_cpp, "  nop_list[%d] = (MachNode *) new %sNode();\n", i, nop);
   }
   fprintf(fp_cpp, "};\n\n");
   fprintf(fp_cpp, "#ifndef PRODUCT\n");
@@ -1328,7 +1328,7 @@
     preplace->next_instruction(root_inst);
     InstructForm *root_form = globals[root_inst]->is_instruction();
     assert( root_form != NULL, "Replacement instruction was not previously defined");
-    fprintf(fp, "        %sNode *root = new (C) %sNode();\n", root_inst, root_inst);
+    fprintf(fp, "        %sNode *root = new %sNode();\n", root_inst, root_inst);
 
     int         inst_num;
     const char *op_name;
@@ -1497,11 +1497,11 @@
         new_oper = frm->is_operand();
         char *tmp = (char *)node->_exprule->_newopconst[new_id];
         if (tmp == NULL) {
-          fprintf(fp,"  MachOper *op%d = new (C) %sOper();\n",
+          fprintf(fp,"  MachOper *op%d = new %sOper();\n",
                   cnt, new_oper->_ident);
         }
         else {
-          fprintf(fp,"  MachOper *op%d = new (C) %sOper(%s);\n",
+          fprintf(fp,"  MachOper *op%d = new %sOper(%s);\n",
                   cnt, new_oper->_ident, tmp);
         }
       }
@@ -1566,7 +1566,7 @@
       }
 
       // Build the node for the instruction
-      fprintf(fp,"\n  %sNode *n%d = new (C) %sNode();\n", new_id, cnt, new_id);
+      fprintf(fp,"\n  %sNode *n%d = new %sNode();\n", new_id, cnt, new_id);
       // Add control edge for this node
       fprintf(fp,"  n%d->add_req(_in[0]);\n", cnt);
       // Build the operand for the value this node defines.
@@ -1729,7 +1729,7 @@
           declared_def = true;
         }
         if (op && op->_interface && op->_interface->is_RegInterface()) {
-          fprintf(fp,"  def = new (C) MachTempNode(state->MachOperGenerator( %s, C ));\n",
+          fprintf(fp,"  def = new MachTempNode(state->MachOperGenerator( %s, C ));\n",
                   machOperEnum(op->_ident));
           fprintf(fp,"  add_req(def);\n");
           // The operand for TEMP is already constructed during
@@ -1760,7 +1760,7 @@
         }
 
         fprintf(fp,"  kill = ");
-        fprintf(fp,"new (C) MachProjNode( %s, %d, (%s), Op_%s );\n",
+        fprintf(fp,"new MachProjNode( %s, %d, (%s), Op_%s );\n",
                 machNode, proj_no++, regmask, ideal_type);
         fprintf(fp,"  proj_list.push(kill);\n");
       }
@@ -2840,7 +2840,7 @@
 // generate code to create a clone for a class derived from MachOper
 //
 // (0)  MachOper  *MachOperXOper::clone(Compile* C) const {
-// (1)    return new (C) MachXOper( _ccode, _c0, _c1, ..., _cn);
+// (1)    return new MachXOper( _ccode, _c0, _c1, ..., _cn);
 // (2)  }
 //
 static void defineClone(FILE *fp, FormDict &globalNames, OperandForm &oper) {
@@ -2849,7 +2849,7 @@
   const int  num_consts    = oper.num_consts(globalNames);
   const bool is_ideal_bool = oper.is_ideal_bool();
   if( (num_consts > 0) ) {
-    fprintf(fp,"  return new (C) %sOper(", oper._ident);
+    fprintf(fp,"  return new %sOper(", oper._ident);
     // generate parameters for constants
     int i = 0;
     fprintf(fp,"_c%d", i);
@@ -2861,7 +2861,7 @@
   }
   else {
     assert( num_consts == 0, "Currently support zero or one constant per operand clone function");
-    fprintf(fp,"  return new (C) %sOper();\n", oper._ident);
+    fprintf(fp,"  return new %sOper();\n", oper._ident);
   }
   // finish method
   fprintf(fp,"}\n");
@@ -3106,7 +3106,7 @@
       defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper);
 
       fprintf(fp,"MachOper  *%sOper::clone(Compile* C) const {\n", oper->_ident);
-      fprintf(fp,"  return  new (C) %sOper(_label, _block_num);\n", oper->_ident);
+      fprintf(fp,"  return  new %sOper(_label, _block_num);\n", oper->_ident);
       fprintf(fp,"}\n");
 
       fprintf(fp,"uint %sOper::opcode() const { return %s; }\n",
@@ -3125,7 +3125,7 @@
       defineIn_RegMask(_CPP_MISC_file._fp, _globalNames, *oper);
 
       fprintf(fp,"MachOper  *%sOper::clone(Compile* C) const {\n", oper->_ident);
-      fprintf(fp,"  return  new (C) %sOper(_method);\n", oper->_ident);
+      fprintf(fp,"  return  new %sOper(_method);\n", oper->_ident);
       fprintf(fp,"}\n");
 
       fprintf(fp,"uint %sOper::opcode() const { return %s; }\n",
@@ -3815,7 +3815,7 @@
 
   // Generate the case statement for this opcode
   fprintf(fp, "  case %s:", opEnumName);
-  fprintf(fp, "\n    return new (C) %sOper(", opName);
+  fprintf(fp, "\n    return new %sOper(", opName);
   // Access parameters for constructor from the stat object
   //
   // Build access to condition code value
@@ -3894,7 +3894,7 @@
   const char *opClass = inst->_ident;
 
   // Create the MachNode object
-  fprintf(fp_cpp, "%s %sNode *node = new (C) %sNode();\n",indent, opClass,opClass);
+  fprintf(fp_cpp, "%s %sNode *node = new %sNode();\n",indent, opClass,opClass);
 
   if ( (inst->num_post_match_opnds() != 0) ) {
     // Instruction that contains operands which are not in match rule.
@@ -3936,7 +3936,7 @@
     // Check for multiple constants and then fill them in.
     // Just like MachOperGenerator
     const char *opName = inst->_matrule->_rChild->_opType;
-    fprintf(fp_cpp, "new (C) %sOper(", opName);
+    fprintf(fp_cpp, "new %sOper(", opName);
     // Grab operand form
     OperandForm *op = (_globalNames[opName])->is_operand();
     // Look up the number of constants
@@ -4010,7 +4010,7 @@
     fprintf(fp_cpp, "// Build CISC version of this instruction\n");
     fprintf(fp_cpp, "MachNode *%sNode::cisc_version( int offset, Compile* C ) {\n", this->_ident);
     // Create the MachNode object
-    fprintf(fp_cpp, "  %sNode *node = new (C) %sNode();\n", name, name);
+    fprintf(fp_cpp, "  %sNode *node = new %sNode();\n", name, name);
     // Fill in the bottom_type where requested
     if ( this->captures_bottom_type(AD.globalNames()) ) {
       fprintf(fp_cpp, "  node->_bottom_type = bottom_type();\n");
@@ -4026,7 +4026,7 @@
     fprintf(fp_cpp, "  fill_new_machnode(node, C);\n");
     // Construct operand to access [stack_pointer + offset]
     fprintf(fp_cpp, "  // Construct operand to access [stack_pointer + offset]\n");
-    fprintf(fp_cpp, "  node->set_opnd_array(cisc_operand(), new (C) %sOper(offset));\n", cisc_oper_name);
+    fprintf(fp_cpp, "  node->set_opnd_array(cisc_operand(), new %sOper(offset));\n", cisc_oper_name);
     fprintf(fp_cpp, "\n");
 
     // Return result and exit scope
@@ -4057,7 +4057,7 @@
     fprintf(fp_cpp, "// Build short branch version of this instruction\n");
     fprintf(fp_cpp, "MachNode *%sNode::short_branch_version(Compile* C) {\n", this->_ident);
     // Create the MachNode object
-    fprintf(fp_cpp, "  %sNode *node = new (C) %sNode();\n", name, name);
+    fprintf(fp_cpp, "  %sNode *node = new %sNode();\n", name, name);
     if( is_ideal_if() ) {
       fprintf(fp_cpp, "  node->_prob = _prob;\n");
       fprintf(fp_cpp, "  node->_fcnt = _fcnt;\n");
--- a/src/share/vm/c1/c1_GraphBuilder.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/c1/c1_GraphBuilder.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -2054,7 +2054,7 @@
   bool will_link;
   ciKlass* klass = stream()->get_klass(will_link);
   assert(klass->is_instance_klass(), "must be an instance klass");
-  NewInstance* new_instance = new NewInstance(klass->as_instance_klass(), state_before);
+  NewInstance* new_instance = new NewInstance(klass->as_instance_klass(), state_before, stream()->is_unresolved_klass());
   _memory->new_instance(new_instance);
   apush(append_split(new_instance));
 }
--- a/src/share/vm/c1/c1_Instruction.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/c1/c1_Instruction.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1291,16 +1291,18 @@
 LEAF(NewInstance, StateSplit)
  private:
   ciInstanceKlass* _klass;
+  bool _is_unresolved;
 
  public:
   // creation
-  NewInstance(ciInstanceKlass* klass, ValueStack* state_before)
+  NewInstance(ciInstanceKlass* klass, ValueStack* state_before, bool is_unresolved)
   : StateSplit(instanceType, state_before)
-  , _klass(klass)
+  , _klass(klass), _is_unresolved(is_unresolved)
   {}
 
   // accessors
   ciInstanceKlass* klass() const                 { return _klass; }
+  bool is_unresolved() const                     { return _is_unresolved; }
 
   virtual bool needs_exception_state() const     { return false; }
 
--- a/src/share/vm/c1/c1_LIRAssembler.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/c1/c1_LIRAssembler.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -336,7 +336,6 @@
 
 
 void LIR_Assembler::add_debug_info_for_branch(CodeEmitInfo* info) {
-  _masm->code_section()->relocate(pc(), relocInfo::poll_type);
   int pc_offset = code_offset();
   flush_debug_info(pc_offset);
   info->record_debug_info(compilation()->debug_info_recorder(), pc_offset);
--- a/src/share/vm/c1/c1_LIRGenerator.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/c1/c1_LIRGenerator.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -466,8 +466,11 @@
 }
 
 
-void LIRGenerator::klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info) {
-  if (!obj->is_loaded() || PatchALot) {
+void LIRGenerator::klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info, bool need_resolve) {
+  /* C2 relies on constant pool entries being resolved (ciTypeFlow), so if TieredCompilation
+   * is active and the class hasn't yet been resolved we need to emit a patch that resolves
+   * the class. */
+  if ((TieredCompilation && need_resolve) || !obj->is_loaded() || PatchALot) {
     assert(info != NULL, "info must be set if class is not loaded");
     __ klass2reg_patch(NULL, r, info);
   } else {
@@ -660,9 +663,18 @@
   __ unlock_object(hdr, object, lock, scratch, slow_path);
 }
 
-
-void LIRGenerator::new_instance(LIR_Opr dst, ciInstanceKlass* klass, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info) {
-  klass2reg_with_patching(klass_reg, klass, info);
+#ifndef PRODUCT
+void LIRGenerator::print_if_not_loaded(const NewInstance* new_instance) {
+  if (PrintNotLoaded && !new_instance->klass()->is_loaded()) {
+    tty->print_cr("   ###class not loaded at new bci %d", new_instance->printable_bci());
+  } else if (PrintNotLoaded && (TieredCompilation && new_instance->is_unresolved())) {
+    tty->print_cr("   ###class not resolved at new bci %d", new_instance->printable_bci());
+  }
+}
+#endif
+
+void LIRGenerator::new_instance(LIR_Opr dst, ciInstanceKlass* klass, bool is_unresolved, LIR_Opr scratch1, LIR_Opr scratch2, LIR_Opr scratch3, LIR_Opr scratch4, LIR_Opr klass_reg, CodeEmitInfo* info) {
+  klass2reg_with_patching(klass_reg, klass, info, is_unresolved);
   // If klass is not loaded we do not know if the klass has finalizers:
   if (UseFastNewInstance && klass->is_loaded()
       && !Klass::layout_helper_needs_slow_path(klass->layout_helper())) {
--- a/src/share/vm/c1/c1_LIRGenerator.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/c1/c1_LIRGenerator.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -169,6 +169,8 @@
     return this;
   }
 
+  void print_if_not_loaded(const NewInstance* new_instance) PRODUCT_RETURN;
+
 #ifdef ASSERT
   LIR_List* lir(const char * file, int line) const {
     _lir->set_file_and_line(file, line);
@@ -307,7 +309,7 @@
 
   void store_stack_parameter (LIR_Opr opr, ByteSize offset_from_sp_in_bytes);
 
-  void klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info);
+  void klass2reg_with_patching(LIR_Opr r, ciMetadata* obj, CodeEmitInfo* info, bool need_resolve = false);
 
   // this loads the length and compares against the index
   void array_range_check          (LIR_Opr array, LIR_Opr index, CodeEmitInfo* null_check_info, CodeEmitInfo* range_check_info);
@@ -325,7 +327,7 @@
   void monitor_enter (LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no, CodeEmitInfo* info_for_exception, CodeEmitInfo* info);
   void monitor_exit  (LIR_Opr object, LIR_Opr lock, LIR_Opr hdr, LIR_Opr scratch, int monitor_no);
 
-  void new_instance    (LIR_Opr  dst, ciInstanceKlass* klass, LIR_Opr  scratch1, LIR_Opr  scratch2, LIR_Opr  scratch3,  LIR_Opr scratch4, LIR_Opr  klass_reg, CodeEmitInfo* info);
+  void new_instance    (LIR_Opr  dst, ciInstanceKlass* klass, bool is_unresolved, LIR_Opr  scratch1, LIR_Opr  scratch2, LIR_Opr  scratch3,  LIR_Opr scratch4, LIR_Opr  klass_reg, CodeEmitInfo* info);
 
   // machine dependent
   void cmp_mem_int(LIR_Condition condition, LIR_Opr base, int disp, int c, CodeEmitInfo* info);
--- a/src/share/vm/c1/c1_Runtime1.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/c1/c1_Runtime1.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -123,24 +123,24 @@
 int Runtime1::_throw_array_store_exception_count = 0;
 int Runtime1::_throw_count = 0;
 
-static int _byte_arraycopy_cnt = 0;
-static int _short_arraycopy_cnt = 0;
-static int _int_arraycopy_cnt = 0;
-static int _long_arraycopy_cnt = 0;
-static int _oop_arraycopy_cnt = 0;
+static int _byte_arraycopy_stub_cnt = 0;
+static int _short_arraycopy_stub_cnt = 0;
+static int _int_arraycopy_stub_cnt = 0;
+static int _long_arraycopy_stub_cnt = 0;
+static int _oop_arraycopy_stub_cnt = 0;
 
 address Runtime1::arraycopy_count_address(BasicType type) {
   switch (type) {
   case T_BOOLEAN:
-  case T_BYTE:   return (address)&_byte_arraycopy_cnt;
+  case T_BYTE:   return (address)&_byte_arraycopy_stub_cnt;
   case T_CHAR:
-  case T_SHORT:  return (address)&_short_arraycopy_cnt;
+  case T_SHORT:  return (address)&_short_arraycopy_stub_cnt;
   case T_FLOAT:
-  case T_INT:    return (address)&_int_arraycopy_cnt;
+  case T_INT:    return (address)&_int_arraycopy_stub_cnt;
   case T_DOUBLE:
-  case T_LONG:   return (address)&_long_arraycopy_cnt;
+  case T_LONG:   return (address)&_long_arraycopy_stub_cnt;
   case T_ARRAY:
-  case T_OBJECT: return (address)&_oop_arraycopy_cnt;
+  case T_OBJECT: return (address)&_oop_arraycopy_stub_cnt;
   default:
     ShouldNotReachHere();
     return NULL;
@@ -1479,13 +1479,13 @@
   tty->print_cr(" _ic_miss_cnt:                    %d", SharedRuntime::_ic_miss_ctr);
   tty->print_cr(" _generic_arraycopy_cnt:          %d", _generic_arraycopy_cnt);
   tty->print_cr(" _generic_arraycopystub_cnt:      %d", _generic_arraycopystub_cnt);
-  tty->print_cr(" _byte_arraycopy_cnt:             %d", _byte_arraycopy_cnt);
-  tty->print_cr(" _short_arraycopy_cnt:            %d", _short_arraycopy_cnt);
-  tty->print_cr(" _int_arraycopy_cnt:              %d", _int_arraycopy_cnt);
-  tty->print_cr(" _long_arraycopy_cnt:             %d", _long_arraycopy_cnt);
+  tty->print_cr(" _byte_arraycopy_cnt:             %d", _byte_arraycopy_stub_cnt);
+  tty->print_cr(" _short_arraycopy_cnt:            %d", _short_arraycopy_stub_cnt);
+  tty->print_cr(" _int_arraycopy_cnt:              %d", _int_arraycopy_stub_cnt);
+  tty->print_cr(" _long_arraycopy_cnt:             %d", _long_arraycopy_stub_cnt);
   tty->print_cr(" _primitive_arraycopy_cnt:        %d", _primitive_arraycopy_cnt);
   tty->print_cr(" _oop_arraycopy_cnt (C):          %d", Runtime1::_oop_arraycopy_cnt);
-  tty->print_cr(" _oop_arraycopy_cnt (stub):       %d", _oop_arraycopy_cnt);
+  tty->print_cr(" _oop_arraycopy_cnt (stub):       %d", _oop_arraycopy_stub_cnt);
   tty->print_cr(" _arraycopy_slowcase_cnt:         %d", _arraycopy_slowcase_cnt);
   tty->print_cr(" _arraycopy_checkcast_cnt:        %d", _arraycopy_checkcast_cnt);
   tty->print_cr(" _arraycopy_checkcast_attempt_cnt:%d", _arraycopy_checkcast_attempt_cnt);
--- a/src/share/vm/classfile/vmSymbols.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/classfile/vmSymbols.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -790,6 +790,26 @@
    do_name(     decrypt_name,                                      "decrypt")                                           \
    do_signature(byteArray_int_int_byteArray_int_signature,         "([BII[BI)I")                                        \
                                                                                                                         \
+  /* support for sun.security.provider.SHA */                                                                           \
+  do_class(sun_security_provider_sha,                              "sun/security/provider/SHA")                         \
+  do_intrinsic(_sha_implCompress, sun_security_provider_sha, implCompress_name, implCompress_signature, F_R)            \
+   do_name(     implCompress_name,                                 "implCompress")                                      \
+   do_signature(implCompress_signature,                            "([BI)V")                                            \
+                                                                                                                        \
+  /* support for sun.security.provider.SHA2 */                                                                          \
+  do_class(sun_security_provider_sha2,                             "sun/security/provider/SHA2")                        \
+  do_intrinsic(_sha2_implCompress, sun_security_provider_sha2, implCompress_name, implCompress_signature, F_R)          \
+                                                                                                                        \
+  /* support for sun.security.provider.SHA5 */                                                                          \
+  do_class(sun_security_provider_sha5,                             "sun/security/provider/SHA5")                        \
+  do_intrinsic(_sha5_implCompress, sun_security_provider_sha5, implCompress_name, implCompress_signature, F_R)          \
+                                                                                                                        \
+  /* support for sun.security.provider.DigestBase */                                                                    \
+  do_class(sun_security_provider_digestbase,                       "sun/security/provider/DigestBase")                  \
+  do_intrinsic(_digestBase_implCompressMB, sun_security_provider_digestbase, implCompressMB_name, implCompressMB_signature, F_R)   \
+   do_name(     implCompressMB_name,                               "implCompressMultiBlock")                            \
+   do_signature(implCompressMB_signature,                          "([BII)I")                                           \
+                                                                                                                        \
   /* support for java.util.zip */                                                                                       \
   do_class(java_util_zip_CRC32,           "java/util/zip/CRC32")                                                        \
   do_intrinsic(_updateCRC32,               java_util_zip_CRC32,   update_name, int2_int_signature,               F_SN)  \
--- a/src/share/vm/code/relocInfo.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/code/relocInfo.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -877,11 +877,7 @@
 void internal_word_Relocation::fix_relocation_after_move(const CodeBuffer* src, CodeBuffer* dest) {
   address target = _target;
   if (target == NULL) {
-    if (addr_in_const()) {
-      target = new_addr_for(*(address*)addr(), src, dest);
-    } else {
-      target = new_addr_for(pd_get_address_from_code(), src, dest);
-    }
+    target = new_addr_for(this->target(), src, dest);
   }
   set_value(target);
 }
@@ -890,7 +886,11 @@
 address internal_word_Relocation::target() {
   address target = _target;
   if (target == NULL) {
-    target = pd_get_address_from_code();
+    if (addr_in_const()) {
+      target = *(address*)addr();
+    } else {
+      target = pd_get_address_from_code();
+    }
   }
   return target;
 }
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1341,13 +1341,14 @@
 bool CMSAdaptiveSizePolicy::print_adaptive_size_policy_on(
                                                     outputStream* st) const {
 
-  if (!UseAdaptiveSizePolicy) return false;
+  if (!UseAdaptiveSizePolicy) {
+    return false;
+  }
 
   GenCollectedHeap* gch = GenCollectedHeap::heap();
-  Generation* gen0 = gch->get_gen(0);
-  DefNewGeneration* def_new = gen0->as_DefNewGeneration();
-  return
-    AdaptiveSizePolicy::print_adaptive_size_policy_on(
+  Generation* young = gch->get_gen(0);
+  DefNewGeneration* def_new = young->as_DefNewGeneration();
+  return AdaptiveSizePolicy::print_adaptive_size_policy_on(
                                          st,
                                          def_new->tenuring_threshold());
 }
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -60,21 +60,21 @@
   if (UseParNewGC) {
     if (UseAdaptiveSizePolicy) {
       _generations[0] = new GenerationSpec(Generation::ASParNew,
-                                           _initial_gen0_size, _max_gen0_size);
+                                           _initial_young_size, _max_young_size);
     } else {
       _generations[0] = new GenerationSpec(Generation::ParNew,
-                                           _initial_gen0_size, _max_gen0_size);
+                                           _initial_young_size, _max_young_size);
     }
   } else {
     _generations[0] = new GenerationSpec(Generation::DefNew,
-                                         _initial_gen0_size, _max_gen0_size);
+                                         _initial_young_size, _max_young_size);
   }
   if (UseAdaptiveSizePolicy) {
     _generations[1] = new GenerationSpec(Generation::ASConcurrentMarkSweep,
-                            _initial_gen1_size, _max_gen1_size);
+                                         _initial_old_size, _max_old_size);
   } else {
     _generations[1] = new GenerationSpec(Generation::ConcurrentMarkSweep,
-                            _initial_gen1_size, _max_gen1_size);
+                                         _initial_old_size, _max_old_size);
   }
 
   if (_generations[0] == NULL || _generations[1] == NULL) {
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1138,8 +1138,8 @@
 
 void CMSCollector::icms_update_allocation_limits()
 {
-  Generation* gen0 = GenCollectedHeap::heap()->get_gen(0);
-  EdenSpace* eden = gen0->as_DefNewGeneration()->eden();
+  Generation* young = GenCollectedHeap::heap()->get_gen(0);
+  EdenSpace* eden = young->as_DefNewGeneration()->eden();
 
   const unsigned int duty_cycle = stats().icms_update_duty_cycle();
   if (CMSTraceIncrementalPacing) {
--- a/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1193,10 +1193,9 @@
   // Does a "full" (forced) collection invoked on this generation collect
   // all younger generations as well? Note that the second conjunct is a
   // hack to allow the collection of the younger gen first if the flag is
-  // set. This is better than using th policy's should_collect_gen0_first()
-  // since that causes us to do an extra unnecessary pair of restart-&-stop-world.
+  // set.
   virtual bool full_collects_younger_generations() const {
-    return UseCMSCompactAtFullCollection && !CollectGen0First;
+    return UseCMSCompactAtFullCollection && !ScavengeBeforeFullGC;
   }
 
   void space_iterate(SpaceClosure* blk, bool usedOnly = false);
--- a/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -3622,7 +3622,7 @@
 
 void G1CollectedHeap::print_tracing_info() const {
   // We'll overload this to mean "trace GC pause statistics."
-  if (TraceGen0Time || TraceGen1Time) {
+  if (TraceYoungGenTime || TraceOldGenTime) {
     // The "G1CollectorPolicy" is keeping track of these stats, so delegate
     // to that.
     g1_policy()->print_tracing_info();
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -809,7 +809,7 @@
   double full_gc_time_sec = end_sec - _full_collection_start_sec;
   double full_gc_time_ms = full_gc_time_sec * 1000.0;
 
-  _trace_gen1_time_data.record_full_collection(full_gc_time_ms);
+  _trace_old_gen_time_data.record_full_collection(full_gc_time_ms);
 
   update_recent_gc_times(end_sec, full_gc_time_ms);
 
@@ -851,7 +851,7 @@
                  _g1->used(), _g1->recalculate_used()));
 
   double s_w_t_ms = (start_time_sec - _stop_world_start) * 1000.0;
-  _trace_gen0_time_data.record_start_collection(s_w_t_ms);
+  _trace_young_gen_time_data.record_start_collection(s_w_t_ms);
   _stop_world_start = 0.0;
 
   record_heap_size_info_at_start(false /* full */);
@@ -906,7 +906,7 @@
 void G1CollectorPolicy::record_concurrent_pause() {
   if (_stop_world_start > 0.0) {
     double yield_ms = (os::elapsedTime() - _stop_world_start) * 1000.0;
-    _trace_gen0_time_data.record_yield_time(yield_ms);
+    _trace_young_gen_time_data.record_yield_time(yield_ms);
   }
 }
 
@@ -993,7 +993,7 @@
   evacuation_info.set_bytes_copied(_bytes_copied_during_gc);
 
   if (update_stats) {
-    _trace_gen0_time_data.record_end_collection(pause_time_ms, phase_times());
+    _trace_young_gen_time_data.record_end_collection(pause_time_ms, phase_times());
     // this is where we update the allocation rate of the application
     double app_time_ms =
       (phase_times()->cur_collection_start_sec() * 1000.0 - _prev_collection_pause_end_ms);
@@ -1415,8 +1415,8 @@
 }
 
 void G1CollectorPolicy::print_tracing_info() const {
-  _trace_gen0_time_data.print();
-  _trace_gen1_time_data.print();
+  _trace_young_gen_time_data.print();
+  _trace_old_gen_time_data.print();
 }
 
 void G1CollectorPolicy::print_yg_surv_rate_info() const {
@@ -1973,9 +1973,9 @@
   _last_gc_was_young = gcs_are_young() ? true : false;
 
   if (_last_gc_was_young) {
-    _trace_gen0_time_data.increment_young_collection_count();
+    _trace_young_gen_time_data.increment_young_collection_count();
   } else {
-    _trace_gen0_time_data.increment_mixed_collection_count();
+    _trace_young_gen_time_data.increment_mixed_collection_count();
   }
 
   // The young list is laid with the survivor regions from the previous
@@ -2156,20 +2156,20 @@
   evacuation_info.set_collectionset_regions(cset_region_length());
 }
 
-void TraceGen0TimeData::record_start_collection(double time_to_stop_the_world_ms) {
-  if(TraceGen0Time) {
+void TraceYoungGenTimeData::record_start_collection(double time_to_stop_the_world_ms) {
+  if(TraceYoungGenTime) {
     _all_stop_world_times_ms.add(time_to_stop_the_world_ms);
   }
 }
 
-void TraceGen0TimeData::record_yield_time(double yield_time_ms) {
-  if(TraceGen0Time) {
+void TraceYoungGenTimeData::record_yield_time(double yield_time_ms) {
+  if(TraceYoungGenTime) {
     _all_yield_times_ms.add(yield_time_ms);
   }
 }
 
-void TraceGen0TimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) {
-  if(TraceGen0Time) {
+void TraceYoungGenTimeData::record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times) {
+  if(TraceYoungGenTime) {
     _total.add(pause_time_ms);
     _other.add(pause_time_ms - phase_times->accounted_time_ms());
     _root_region_scan_wait.add(phase_times->root_region_scan_wait_time_ms());
@@ -2194,34 +2194,34 @@
   }
 }
 
-void TraceGen0TimeData::increment_young_collection_count() {
-  if(TraceGen0Time) {
+void TraceYoungGenTimeData::increment_young_collection_count() {
+  if(TraceYoungGenTime) {
     ++_young_pause_num;
   }
 }
 
-void TraceGen0TimeData::increment_mixed_collection_count() {
-  if(TraceGen0Time) {
+void TraceYoungGenTimeData::increment_mixed_collection_count() {
+  if(TraceYoungGenTime) {
     ++_mixed_pause_num;
   }
 }
 
-void TraceGen0TimeData::print_summary(const char* str,
-                                      const NumberSeq* seq) const {
+void TraceYoungGenTimeData::print_summary(const char* str,
+                                          const NumberSeq* seq) const {
   double sum = seq->sum();
   gclog_or_tty->print_cr("%-27s = %8.2lf s (avg = %8.2lf ms)",
                 str, sum / 1000.0, seq->avg());
 }
 
-void TraceGen0TimeData::print_summary_sd(const char* str,
-                                         const NumberSeq* seq) const {
+void TraceYoungGenTimeData::print_summary_sd(const char* str,
+                                             const NumberSeq* seq) const {
   print_summary(str, seq);
   gclog_or_tty->print_cr("%+45s = %5d, std dev = %8.2lf ms, max = %8.2lf ms)",
                 "(num", seq->num(), seq->sd(), seq->maximum());
 }
 
-void TraceGen0TimeData::print() const {
-  if (!TraceGen0Time) {
+void TraceYoungGenTimeData::print() const {
+  if (!TraceYoungGenTime) {
     return;
   }
 
@@ -2258,14 +2258,14 @@
   print_summary_sd("   Yields", &_all_yield_times_ms);
 }
 
-void TraceGen1TimeData::record_full_collection(double full_gc_time_ms) {
-  if (TraceGen1Time) {
+void TraceOldGenTimeData::record_full_collection(double full_gc_time_ms) {
+  if (TraceOldGenTime) {
     _all_full_gc_times.add(full_gc_time_ms);
   }
 }
 
-void TraceGen1TimeData::print() const {
-  if (!TraceGen1Time) {
+void TraceOldGenTimeData::print() const {
+  if (!TraceOldGenTime) {
     return;
   }
 
--- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -38,10 +38,10 @@
 class CollectionSetChooser;
 class G1GCPhaseTimes;
 
-// TraceGen0Time collects data on _both_ young and mixed evacuation pauses
+// TraceYoungGenTime collects data on _both_ young and mixed evacuation pauses
 // (the latter may contain non-young regions - i.e. regions that are
-// technically in Gen1) while TraceGen1Time collects data about full GCs.
-class TraceGen0TimeData : public CHeapObj<mtGC> {
+// technically in old) while TraceOldGenTime collects data about full GCs.
+class TraceYoungGenTimeData : public CHeapObj<mtGC> {
  private:
   unsigned  _young_pause_num;
   unsigned  _mixed_pause_num;
@@ -66,7 +66,7 @@
   void print_summary_sd(const char* str, const NumberSeq* seq) const;
 
 public:
-   TraceGen0TimeData() : _young_pause_num(0), _mixed_pause_num(0) {};
+   TraceYoungGenTimeData() : _young_pause_num(0), _mixed_pause_num(0) {};
   void record_start_collection(double time_to_stop_the_world_ms);
   void record_yield_time(double yield_time_ms);
   void record_end_collection(double pause_time_ms, G1GCPhaseTimes* phase_times);
@@ -75,7 +75,7 @@
   void print() const;
 };
 
-class TraceGen1TimeData : public CHeapObj<mtGC> {
+class TraceOldGenTimeData : public CHeapObj<mtGC> {
  private:
   NumberSeq _all_full_gc_times;
 
@@ -187,8 +187,8 @@
   TruncatedSeq* _concurrent_mark_remark_times_ms;
   TruncatedSeq* _concurrent_mark_cleanup_times_ms;
 
-  TraceGen0TimeData _trace_gen0_time_data;
-  TraceGen1TimeData _trace_gen1_time_data;
+  TraceYoungGenTimeData _trace_young_gen_time_data;
+  TraceOldGenTimeData   _trace_old_gen_time_data;
 
   double _stop_world_start;
 
@@ -202,20 +202,20 @@
   // locker is active. This should be >= _young_list_target_length;
   uint _young_list_max_length;
 
-  bool                  _last_gc_was_young;
+  bool _last_gc_was_young;
 
-  bool                  _during_marking;
-  bool                  _in_marking_window;
-  bool                  _in_marking_window_im;
+  bool _during_marking;
+  bool _in_marking_window;
+  bool _in_marking_window_im;
 
-  SurvRateGroup*        _short_lived_surv_rate_group;
-  SurvRateGroup*        _survivor_surv_rate_group;
+  SurvRateGroup* _short_lived_surv_rate_group;
+  SurvRateGroup* _survivor_surv_rate_group;
   // add here any more surv rate groups
 
-  double                _gc_overhead_perc;
+  double _gc_overhead_perc;
 
   double _reserve_factor;
-  uint _reserve_regions;
+  uint   _reserve_regions;
 
   bool during_marking() {
     return _during_marking;
--- a/src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/parallelScavenge/adjoiningGenerations.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -35,14 +35,14 @@
 AdjoiningGenerations::AdjoiningGenerations(ReservedSpace old_young_rs,
                                            GenerationSizer* policy,
                                            size_t alignment) :
-  _virtual_spaces(old_young_rs, policy->min_gen1_size(),
-                  policy->min_gen0_size(), alignment) {
-  size_t init_low_byte_size = policy->initial_gen1_size();
-  size_t min_low_byte_size = policy->min_gen1_size();
-  size_t max_low_byte_size = policy->max_gen1_size();
-  size_t init_high_byte_size = policy->initial_gen0_size();
-  size_t min_high_byte_size = policy->min_gen0_size();
-  size_t max_high_byte_size = policy->max_gen0_size();
+  _virtual_spaces(old_young_rs, policy->min_old_size(),
+                  policy->min_young_size(), alignment) {
+  size_t init_low_byte_size = policy->initial_old_size();
+  size_t min_low_byte_size = policy->min_old_size();
+  size_t max_low_byte_size = policy->max_old_size();
+  size_t init_high_byte_size = policy->initial_young_size();
+  size_t min_high_byte_size = policy->min_young_size();
+  size_t max_high_byte_size = policy->max_young_size();
 
   assert(min_low_byte_size <= init_low_byte_size &&
          init_low_byte_size <= max_low_byte_size, "Parameter check");
--- a/src/share/vm/gc_implementation/parallelScavenge/generationSizer.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/parallelScavenge/generationSizer.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -32,8 +32,8 @@
                   SIZE_FORMAT "," SIZE_FORMAT " "
                   SIZE_FORMAT,
                   str,
-                  _min_gen1_size / K, _max_gen1_size / K,
-                  _min_gen0_size / K, _max_gen0_size / K,
+                  _min_old_size / K, _max_old_size / K,
+                  _min_young_size / K, _max_young_size / K,
                   _max_heap_byte_size / K);
   }
 }
--- a/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -623,11 +623,11 @@
 }
 
 void ParallelScavengeHeap::print_tracing_info() const {
-  if (TraceGen0Time) {
+  if (TraceYoungGenTime) {
     double time = PSScavenge::accumulated_time()->seconds();
     tty->print_cr("[Accumulated GC generation 0 time %3.7f secs]", time);
   }
-  if (TraceGen1Time) {
+  if (TraceOldGenTime) {
     double time = UseParallelOldGC ? PSParallelCompact::accumulated_time()->seconds() : PSMarkSweep::accumulated_time()->seconds();
     tty->print_cr("[Accumulated GC generation 1 time %3.7f secs]", time);
   }
--- a/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/parallelScavenge/psMarkSweep.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -174,7 +174,7 @@
     TraceCollectorStats tcs(counters());
     TraceMemoryManagerStats tms(true /* Full GC */,gc_cause);
 
-    if (TraceGen1Time) accumulated_time()->start();
+    if (TraceOldGenTime) accumulated_time()->start();
 
     // Let the size policy know we're starting
     size_policy->major_collection_begin();
@@ -354,7 +354,7 @@
     // We collected the heap, recalculate the metaspace capacity
     MetaspaceGC::compute_new_size();
 
-    if (TraceGen1Time) accumulated_time()->stop();
+    if (TraceOldGenTime) accumulated_time()->stop();
 
     if (PrintGC) {
       if (PrintGCDetails) {
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -2061,7 +2061,7 @@
     TraceCollectorStats tcs(counters());
     TraceMemoryManagerStats tms(true /* Full GC */,gc_cause);
 
-    if (TraceGen1Time) accumulated_time()->start();
+    if (TraceOldGenTime) accumulated_time()->start();
 
     // Let the size policy know we're starting
     size_policy->major_collection_begin();
@@ -2188,7 +2188,7 @@
     // Resize the metaspace capacity after a collection
     MetaspaceGC::compute_new_size();
 
-    if (TraceGen1Time) accumulated_time()->stop();
+    if (TraceOldGenTime) accumulated_time()->stop();
 
     if (PrintGC) {
       if (PrintGCDetails) {
--- a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -336,7 +336,7 @@
     TraceCollectorStats tcs(counters());
     TraceMemoryManagerStats tms(false /* not full GC */,gc_cause);
 
-    if (TraceGen0Time) accumulated_time()->start();
+    if (TraceYoungGenTime) accumulated_time()->start();
 
     // Let the size policy know we're starting
     size_policy->minor_collection_begin();
@@ -660,7 +660,7 @@
       CardTableExtension::verify_all_young_refs_imprecise();
     }
 
-    if (TraceGen0Time) accumulated_time()->stop();
+    if (TraceYoungGenTime) accumulated_time()->stop();
 
     if (PrintGC) {
       if (PrintGCDetails) {
--- a/src/share/vm/memory/collectorPolicy.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/memory/collectorPolicy.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -196,13 +196,13 @@
 // GenCollectorPolicy methods
 
 GenCollectorPolicy::GenCollectorPolicy() :
-    _min_gen0_size(0),
-    _initial_gen0_size(0),
-    _max_gen0_size(0),
+    _min_young_size(0),
+    _initial_young_size(0),
+    _max_young_size(0),
     _gen_alignment(0),
-    _min_gen1_size(0),
-    _initial_gen1_size(0),
-    _max_gen1_size(0),
+    _min_old_size(0),
+    _initial_old_size(0),
+    _max_old_size(0),
     _generations(NULL)
 {}
 
@@ -236,7 +236,7 @@
 #ifdef ASSERT
 void GenCollectorPolicy::assert_flags() {
   CollectorPolicy::assert_flags();
-  assert(NewSize >= _min_gen0_size, "Ergonomics decided on a too small young gen size");
+  assert(NewSize >= _min_young_size, "Ergonomics decided on a too small young gen size");
   assert(NewSize <= MaxNewSize, "Ergonomics decided on incompatible initial and maximum young gen sizes");
   assert(FLAG_IS_DEFAULT(MaxNewSize) || MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young gen and heap sizes");
   assert(NewSize % _gen_alignment == 0, "NewSize alignment");
@@ -249,28 +249,28 @@
   CollectorPolicy::assert_size_info();
   // GenCollectorPolicy::initialize_size_info may update the MaxNewSize
   assert(MaxNewSize < MaxHeapSize, "Ergonomics decided on incompatible maximum young and heap sizes");
-  assert(NewSize == _initial_gen0_size, "Discrepancy between NewSize flag and local storage");
-  assert(MaxNewSize == _max_gen0_size, "Discrepancy between MaxNewSize flag and local storage");
-  assert(OldSize == _initial_gen1_size, "Discrepancy between OldSize flag and local storage");
-  assert(_min_gen0_size <= _initial_gen0_size, "Ergonomics decided on incompatible minimum and initial young gen sizes");
-  assert(_initial_gen0_size <= _max_gen0_size, "Ergonomics decided on incompatible initial and maximum young gen sizes");
-  assert(_min_gen0_size % _gen_alignment == 0, "_min_gen0_size alignment");
-  assert(_initial_gen0_size % _gen_alignment == 0, "_initial_gen0_size alignment");
-  assert(_max_gen0_size % _gen_alignment == 0, "_max_gen0_size alignment");
-  assert(_min_gen0_size <= bound_minus_alignment(_min_gen0_size, _min_heap_byte_size),
+  assert(NewSize == _initial_young_size, "Discrepancy between NewSize flag and local storage");
+  assert(MaxNewSize == _max_young_size, "Discrepancy between MaxNewSize flag and local storage");
+  assert(OldSize == _initial_old_size, "Discrepancy between OldSize flag and local storage");
+  assert(_min_young_size <= _initial_young_size, "Ergonomics decided on incompatible minimum and initial young gen sizes");
+  assert(_initial_young_size <= _max_young_size, "Ergonomics decided on incompatible initial and maximum young gen sizes");
+  assert(_min_young_size % _gen_alignment == 0, "_min_young_size alignment");
+  assert(_initial_young_size % _gen_alignment == 0, "_initial_young_size alignment");
+  assert(_max_young_size % _gen_alignment == 0, "_max_young_size alignment");
+  assert(_min_young_size <= bound_minus_alignment(_min_young_size, _min_heap_byte_size),
       "Ergonomics made minimum young generation larger than minimum heap");
-  assert(_initial_gen0_size <=  bound_minus_alignment(_initial_gen0_size, _initial_heap_byte_size),
+  assert(_initial_young_size <=  bound_minus_alignment(_initial_young_size, _initial_heap_byte_size),
       "Ergonomics made initial young generation larger than initial heap");
-  assert(_max_gen0_size <= bound_minus_alignment(_max_gen0_size, _max_heap_byte_size),
+  assert(_max_young_size <= bound_minus_alignment(_max_young_size, _max_heap_byte_size),
       "Ergonomics made maximum young generation lager than maximum heap");
-  assert(_min_gen1_size <= _initial_gen1_size, "Ergonomics decided on incompatible minimum and initial old gen sizes");
-  assert(_initial_gen1_size <= _max_gen1_size, "Ergonomics decided on incompatible initial and maximum old gen sizes");
-  assert(_max_gen1_size % _gen_alignment == 0, "_max_gen1_size alignment");
-  assert(_initial_gen1_size % _gen_alignment == 0, "_initial_gen1_size alignment");
-  assert(_max_heap_byte_size <= (_max_gen0_size + _max_gen1_size), "Total maximum heap sizes must be sum of generation maximum sizes");
-  assert(_min_gen0_size + _min_gen1_size <= _min_heap_byte_size, "Minimum generation sizes exceed minimum heap size");
-  assert(_initial_gen0_size + _initial_gen1_size == _initial_heap_byte_size, "Initial generation sizes should match initial heap size");
-  assert(_max_gen0_size + _max_gen1_size == _max_heap_byte_size, "Maximum generation sizes should match maximum heap size");
+  assert(_min_old_size <= _initial_old_size, "Ergonomics decided on incompatible minimum and initial old gen sizes");
+  assert(_initial_old_size <= _max_old_size, "Ergonomics decided on incompatible initial and maximum old gen sizes");
+  assert(_max_old_size % _gen_alignment == 0, "_max_old_size alignment");
+  assert(_initial_old_size % _gen_alignment == 0, "_initial_old_size alignment");
+  assert(_max_heap_byte_size <= (_max_young_size + _max_old_size), "Total maximum heap sizes must be sum of generation maximum sizes");
+  assert(_min_young_size + _min_old_size <= _min_heap_byte_size, "Minimum generation sizes exceed minimum heap size");
+  assert(_initial_young_size + _initial_old_size == _initial_heap_byte_size, "Initial generation sizes should match initial heap size");
+  assert(_max_young_size + _max_old_size == _max_heap_byte_size, "Maximum generation sizes should match maximum heap size");
 }
 #endif // ASSERT
 
@@ -323,8 +323,8 @@
     // later when setting the initial and minimum young generation size.
     NewSize = bounded_new_size;
   }
-  _min_gen0_size = smallest_new_size;
-  _initial_gen0_size = NewSize;
+  _min_young_size = smallest_new_size;
+  _initial_young_size = NewSize;
 
   if (!FLAG_IS_DEFAULT(MaxNewSize)) {
     if (MaxNewSize >= MaxHeapSize) {
@@ -338,14 +338,14 @@
       FLAG_SET_ERGO(uintx, MaxNewSize, smaller_max_new_size);
       if (NewSize > MaxNewSize) {
         FLAG_SET_ERGO(uintx, NewSize, MaxNewSize);
-        _initial_gen0_size = NewSize;
+        _initial_young_size = NewSize;
       }
-    } else if (MaxNewSize < _initial_gen0_size) {
-      FLAG_SET_ERGO(uintx, MaxNewSize, _initial_gen0_size);
+    } else if (MaxNewSize < _initial_young_size) {
+      FLAG_SET_ERGO(uintx, MaxNewSize, _initial_young_size);
     } else if (!is_size_aligned(MaxNewSize, _gen_alignment)) {
       FLAG_SET_ERGO(uintx, MaxNewSize, align_size_down(MaxNewSize, _gen_alignment));
     }
-    _max_gen0_size = MaxNewSize;
+    _max_young_size = MaxNewSize;
   }
 
   if (NewSize > MaxNewSize) {
@@ -357,7 +357,7 @@
               NewSize/K, MaxNewSize/K, NewSize/K);
     }
     FLAG_SET_ERGO(uintx, MaxNewSize, NewSize);
-    _max_gen0_size = MaxNewSize;
+    _max_young_size = MaxNewSize;
   }
 
   if (SurvivorRatio < 1 || NewRatio < 1) {
@@ -393,7 +393,7 @@
       double shrink_factor = (double) MaxHeapSize / calculated_size;
       uintx smaller_new_size = align_size_down((uintx)(NewSize * shrink_factor), _gen_alignment);
       FLAG_SET_ERGO(uintx, NewSize, MAX2(young_gen_size_lower_bound(), smaller_new_size));
-      _initial_gen0_size = NewSize;
+      _initial_young_size = NewSize;
 
       // OldSize is already aligned because above we aligned MaxHeapSize to
       // _heap_alignment, and we just made sure that NewSize is aligned to
@@ -406,16 +406,16 @@
     }
   }
 
-  // Update NewSize, if possible, to avoid sizing gen0 to small when only
+  // Update NewSize, if possible, to avoid sizing the young gen too small when only
   // OldSize is set on the command line.
   if (FLAG_IS_CMDLINE(OldSize) && !FLAG_IS_CMDLINE(NewSize)) {
     if (OldSize < _initial_heap_byte_size) {
       size_t new_size = _initial_heap_byte_size - OldSize;
-      // Need to compare against the flag value for max since _max_gen0_size
+      // Need to compare against the flag value for max since _max_young_size
       // might not have been set yet.
-      if (new_size >= _min_gen0_size && new_size <= MaxNewSize) {
+      if (new_size >= _min_young_size && new_size <= MaxNewSize) {
         FLAG_SET_ERGO(uintx, NewSize, new_size);
-        _initial_gen0_size = NewSize;
+        _initial_young_size = NewSize;
       }
     }
   }
@@ -444,97 +444,77 @@
 void GenCollectorPolicy::initialize_size_info() {
   CollectorPolicy::initialize_size_info();
 
-  // _space_alignment is used for alignment within a generation.
-  // There is additional alignment done down stream for some
-  // collectors that sometimes causes unwanted rounding up of
-  // generations sizes.
+  _initial_young_size = NewSize;
+  _max_young_size = MaxNewSize;
+  _initial_old_size = OldSize;
 
-  // Determine maximum size of gen0
+  // Determine maximum size of the young generation.
 
-  size_t max_new_size = 0;
-  if (!FLAG_IS_DEFAULT(MaxNewSize)) {
-    max_new_size = MaxNewSize;
-  } else {
-    max_new_size = scale_by_NewRatio_aligned(_max_heap_byte_size);
+  if (FLAG_IS_DEFAULT(MaxNewSize)) {
+    _max_young_size = scale_by_NewRatio_aligned(_max_heap_byte_size);
     // Bound the maximum size by NewSize below (since it historically
     // would have been NewSize and because the NewRatio calculation could
     // yield a size that is too small) and bound it by MaxNewSize above.
     // Ergonomics plays here by previously calculating the desired
     // NewSize and MaxNewSize.
-    max_new_size = MIN2(MAX2(max_new_size, NewSize), MaxNewSize);
+    _max_young_size = MIN2(MAX2(_max_young_size, _initial_young_size), MaxNewSize);
   }
-  assert(max_new_size > 0, "All paths should set max_new_size");
 
-  // Given the maximum gen0 size, determine the initial and
-  // minimum gen0 sizes.
+  // Given the maximum young size, determine the initial and
+  // minimum young sizes.
 
   if (_max_heap_byte_size == _initial_heap_byte_size) {
-    // The maxium and initial heap sizes are the same so the generation's
+    // The maximum and initial heap sizes are the same so the generation's
     // initial size must be the same as it maximum size. Use NewSize as the
     // size if set on command line.
-    size_t fixed_young_size = FLAG_IS_CMDLINE(NewSize) ? NewSize : max_new_size;
-
-    _initial_gen0_size = fixed_young_size;
-    _max_gen0_size = fixed_young_size;
+    _max_young_size = FLAG_IS_CMDLINE(NewSize) ? NewSize : _max_young_size;
+    _initial_young_size = _max_young_size;
 
     // Also update the minimum size if min == initial == max.
     if (_max_heap_byte_size == _min_heap_byte_size) {
-      _min_gen0_size = fixed_young_size;
+      _min_young_size = _max_young_size;
     }
   } else {
-    size_t desired_new_size = 0;
     if (FLAG_IS_CMDLINE(NewSize)) {
       // If NewSize is set on the command line, we should use it as
       // the initial size, but make sure it is within the heap bounds.
-      desired_new_size =
-        MIN2(max_new_size, bound_minus_alignment(NewSize, _initial_heap_byte_size));
-      _min_gen0_size = bound_minus_alignment(desired_new_size, _min_heap_byte_size);
+      _initial_young_size =
+        MIN2(_max_young_size, bound_minus_alignment(NewSize, _initial_heap_byte_size));
+      _min_young_size = bound_minus_alignment(_initial_young_size, _min_heap_byte_size);
     } else {
       // For the case where NewSize is not set on the command line, use
       // NewRatio to size the initial generation size. Use the current
       // NewSize as the floor, because if NewRatio is overly large, the resulting
       // size can be too small.
-      desired_new_size =
-        MIN2(max_new_size, MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize));
+      _initial_young_size =
+        MIN2(_max_young_size, MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize));
     }
-    _initial_gen0_size = desired_new_size;
-    _max_gen0_size = max_new_size;
-  }
-
-  // Write back to flags if necessary.
-  if (NewSize != _initial_gen0_size) {
-    FLAG_SET_ERGO(uintx, NewSize, _initial_gen0_size);
-  }
-
-  if (MaxNewSize != _max_gen0_size) {
-    FLAG_SET_ERGO(uintx, MaxNewSize, _max_gen0_size);
   }
 
   if (PrintGCDetails && Verbose) {
-    gclog_or_tty->print_cr("1: Minimum gen0 " SIZE_FORMAT "  Initial gen0 "
-      SIZE_FORMAT "  Maximum gen0 " SIZE_FORMAT,
-      _min_gen0_size, _initial_gen0_size, _max_gen0_size);
+    gclog_or_tty->print_cr("1: Minimum young " SIZE_FORMAT "  Initial young "
+      SIZE_FORMAT "  Maximum young " SIZE_FORMAT,
+      _min_young_size, _initial_young_size, _max_young_size);
   }
 
   // At this point the minimum, initial and maximum sizes
-  // of the overall heap and of gen0 have been determined.
-  // The maximum gen1 size can be determined from the maximum gen0
+  // of the overall heap and of the young generation have been determined.
+  // The maximum old size can be determined from the maximum young
   // and maximum heap size since no explicit flags exist
-  // for setting the gen1 maximum.
-  _max_gen1_size = MAX2(_max_heap_byte_size - _max_gen0_size, _gen_alignment);
+  // for setting the old generation maximum.
+  _max_old_size = MAX2(_max_heap_byte_size - _max_young_size, _gen_alignment);
 
   // If no explicit command line flag has been set for the
-  // gen1 size, use what is left for gen1
+  // old generation size, use what is left.
   if (!FLAG_IS_CMDLINE(OldSize)) {
     // The user has not specified any value but the ergonomics
     // may have chosen a value (which may or may not be consistent
     // with the overall heap size).  In either case make
     // the minimum, maximum and initial sizes consistent
-    // with the gen0 sizes and the overall heap sizes.
-    _min_gen1_size = _gen_alignment;
-    _initial_gen1_size = MIN2(_max_gen1_size, MAX2(_initial_heap_byte_size - _initial_gen0_size, _min_gen1_size));
-    // _max_gen1_size has already been made consistent above
-    FLAG_SET_ERGO(uintx, OldSize, _initial_gen1_size);
+    // with the young sizes and the overall heap sizes.
+    _min_old_size = _gen_alignment;
+    _initial_old_size = MIN2(_max_old_size, MAX2(_initial_heap_byte_size - _initial_young_size, _min_old_size));
+    // _max_old_size has already been made consistent above.
   } else {
     // OldSize has been explicitly set on the command line. Use it
     // for the initial size but make sure the minimum allow a young
@@ -543,69 +523,68 @@
     // with other command line flags, issue a warning.
     // The generation minimums and the overall heap minimum should
     // be within one generation alignment.
-    if (OldSize > _max_gen1_size) {
+    if (_initial_old_size > _max_old_size) {
       warning("Inconsistency between maximum heap size and maximum "
           "generation sizes: using maximum heap = " SIZE_FORMAT
           " -XX:OldSize flag is being ignored",
           _max_heap_byte_size);
-      FLAG_SET_ERGO(uintx, OldSize, _max_gen1_size);
+      _initial_old_size = _max_old_size;
     }
 
-    _min_gen1_size = MIN2(OldSize, _min_heap_byte_size - _min_gen0_size);
-    _initial_gen1_size = OldSize;
+    _min_old_size = MIN2(_initial_old_size, _min_heap_byte_size - _min_young_size);
   }
 
   // The initial generation sizes should match the initial heap size,
   // if not issue a warning and resize the generations. This behavior
   // differs from JDK8 where the generation sizes have higher priority
   // than the initial heap size.
-  if ((_initial_gen1_size + _initial_gen0_size) != _initial_heap_byte_size) {
+  if ((_initial_old_size + _initial_young_size) != _initial_heap_byte_size) {
     warning("Inconsistency between generation sizes and heap size, resizing "
             "the generations to fit the heap.");
 
-    size_t desired_gen0_size = _initial_heap_byte_size - _initial_gen1_size;
-    if (_initial_heap_byte_size < _initial_gen1_size) {
+    size_t desired_young_size = _initial_heap_byte_size - _initial_old_size;
+    if (_initial_heap_byte_size < _initial_old_size) {
       // Old want all memory, use minimum for young and rest for old
-      _initial_gen0_size = _min_gen0_size;
-      _initial_gen1_size = _initial_heap_byte_size - _min_gen0_size;
-    } else if (desired_gen0_size > _max_gen0_size) {
+      _initial_young_size = _min_young_size;
+      _initial_old_size = _initial_heap_byte_size - _min_young_size;
+    } else if (desired_young_size > _max_young_size) {
       // Need to increase both young and old generation
-      _initial_gen0_size = _max_gen0_size;
-      _initial_gen1_size = _initial_heap_byte_size - _max_gen0_size;
-    } else if (desired_gen0_size < _min_gen0_size) {
+      _initial_young_size = _max_young_size;
+      _initial_old_size = _initial_heap_byte_size - _max_young_size;
+    } else if (desired_young_size < _min_young_size) {
       // Need to decrease both young and old generation
-      _initial_gen0_size = _min_gen0_size;
-      _initial_gen1_size = _initial_heap_byte_size - _min_gen0_size;
+      _initial_young_size = _min_young_size;
+      _initial_old_size = _initial_heap_byte_size - _min_young_size;
     } else {
       // The young generation boundaries allow us to only update the
       // young generation.
-      _initial_gen0_size = desired_gen0_size;
+      _initial_young_size = desired_young_size;
     }
 
     if (PrintGCDetails && Verbose) {
-      gclog_or_tty->print_cr("2: Minimum gen0 " SIZE_FORMAT "  Initial gen0 "
-        SIZE_FORMAT "  Maximum gen0 " SIZE_FORMAT,
-        _min_gen0_size, _initial_gen0_size, _max_gen0_size);
+      gclog_or_tty->print_cr("2: Minimum young " SIZE_FORMAT "  Initial young "
+        SIZE_FORMAT "  Maximum young " SIZE_FORMAT,
+        _min_young_size, _initial_young_size, _max_young_size);
     }
   }
 
-  // Write back to flags if necessary
-  if (NewSize != _initial_gen0_size) {
-    FLAG_SET_ERGO(uintx, NewSize, _initial_gen0_size);
+  // Write back to flags if necessary.
+  if (NewSize != _initial_young_size) {
+    FLAG_SET_ERGO(uintx, NewSize, _initial_young_size);
   }
 
-  if (MaxNewSize != _max_gen0_size) {
-    FLAG_SET_ERGO(uintx, MaxNewSize, _max_gen0_size);
+  if (MaxNewSize != _max_young_size) {
+    FLAG_SET_ERGO(uintx, MaxNewSize, _max_young_size);
   }
 
-  if (OldSize != _initial_gen1_size) {
-    FLAG_SET_ERGO(uintx, OldSize, _initial_gen1_size);
+  if (OldSize != _initial_old_size) {
+    FLAG_SET_ERGO(uintx, OldSize, _initial_old_size);
   }
 
   if (PrintGCDetails && Verbose) {
-    gclog_or_tty->print_cr("Minimum gen1 " SIZE_FORMAT "  Initial gen1 "
-      SIZE_FORMAT "  Maximum gen1 " SIZE_FORMAT,
-      _min_gen1_size, _initial_gen1_size, _max_gen1_size);
+    gclog_or_tty->print_cr("Minimum old " SIZE_FORMAT "  Initial old "
+      SIZE_FORMAT "  Maximum old " SIZE_FORMAT,
+      _min_old_size, _initial_old_size, _max_old_size);
   }
 
   DEBUG_ONLY(GenCollectorPolicy::assert_size_info();)
@@ -631,11 +610,11 @@
     HandleMark hm; // Discard any handles allocated in each iteration.
 
     // First allocation attempt is lock-free.
-    Generation *gen0 = gch->get_gen(0);
-    assert(gen0->supports_inline_contig_alloc(),
+    Generation *young = gch->get_gen(0);
+    assert(young->supports_inline_contig_alloc(),
       "Otherwise, must do alloc within heap lock");
-    if (gen0->should_allocate(size, is_tlab)) {
-      result = gen0->par_allocate(size, is_tlab);
+    if (young->should_allocate(size, is_tlab)) {
+      result = young->par_allocate(size, is_tlab);
       if (result != NULL) {
         assert(gch->is_in_reserved(result), "result not in heap");
         return result;
@@ -917,8 +896,8 @@
 bool GenCollectorPolicy::should_try_older_generation_allocation(
         size_t word_size) const {
   GenCollectedHeap* gch = GenCollectedHeap::heap();
-  size_t gen0_capacity = gch->get_gen(0)->capacity_before_gc();
-  return    (word_size > heap_word_size(gen0_capacity))
+  size_t young_capacity = gch->get_gen(0)->capacity_before_gc();
+  return    (word_size > heap_word_size(young_capacity))
          || GC_locker::is_active_and_needs_gc()
          || gch->incremental_collection_failed();
 }
@@ -940,11 +919,11 @@
   }
 
   if (UseParNewGC) {
-    _generations[0] = new GenerationSpec(Generation::ParNew, _initial_gen0_size, _max_gen0_size);
+    _generations[0] = new GenerationSpec(Generation::ParNew, _initial_young_size, _max_young_size);
   } else {
-    _generations[0] = new GenerationSpec(Generation::DefNew, _initial_gen0_size, _max_gen0_size);
+    _generations[0] = new GenerationSpec(Generation::DefNew, _initial_young_size, _max_young_size);
   }
-  _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_gen1_size, _max_gen1_size);
+  _generations[1] = new GenerationSpec(Generation::MarkSweepCompact, _initial_old_size, _max_old_size);
 
   if (_generations[0] == NULL || _generations[1] == NULL) {
     vm_exit_during_initialization("Unable to allocate gen spec");
@@ -978,18 +957,18 @@
     flag_value = 20 * M;
     set_basic_flag_values();
     FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
-    verify_gen0_min(flag_value);
+    verify_young_min(flag_value);
 
     set_basic_flag_values();
     FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
-    verify_gen0_initial(flag_value);
+    verify_young_initial(flag_value);
 
     // If NewSize is set on command line, but is larger than the min
     // heap size, it should only be used for initial young size.
     flag_value = 80 * M;
     set_basic_flag_values();
     FLAG_SET_CMDLINE(uintx, NewSize, flag_value);
-    verify_gen0_initial(flag_value);
+    verify_young_initial(flag_value);
 
     // If NewSize has been ergonomically set, the collector policy
     // should use it for min but calculate the initial young size
@@ -997,11 +976,11 @@
     flag_value = 20 * M;
     set_basic_flag_values();
     FLAG_SET_ERGO(uintx, NewSize, flag_value);
-    verify_gen0_min(flag_value);
+    verify_young_min(flag_value);
 
     set_basic_flag_values();
     FLAG_SET_ERGO(uintx, NewSize, flag_value);
-    verify_scaled_gen0_initial(InitialHeapSize);
+    verify_scaled_young_initial(InitialHeapSize);
 
     restore_flags();
   }
@@ -1016,11 +995,11 @@
       flag_value = 20 * M;
       set_basic_flag_values();
       FLAG_SET_CMDLINE(uintx, OldSize, flag_value);
-      verify_gen1_min(flag_value);
+      verify_old_min(flag_value);
 
       set_basic_flag_values();
       FLAG_SET_CMDLINE(uintx, OldSize, flag_value);
-      verify_gen1_initial(flag_value);
+      verify_old_initial(flag_value);
 
       // If MaxNewSize is large, the maximum OldSize will be less than
       // what's requested on the command line and it should be reset
@@ -1031,46 +1010,46 @@
       FLAG_SET_CMDLINE(uintx, MaxNewSize, 170*M);
       // Calculate what we expect the flag to be.
       flag_value = MaxHeapSize - MaxNewSize;
-      verify_gen1_initial(flag_value);
+      verify_old_initial(flag_value);
 
   }
 
-  static void verify_gen0_min(size_t expected) {
+  static void verify_young_min(size_t expected) {
     MarkSweepPolicy msp;
     msp.initialize_all();
 
-    assert(msp.min_gen0_size() <= expected, err_msg("%zu  > %zu", msp.min_gen0_size(), expected));
+    assert(msp.min_young_size() <= expected, err_msg("%zu  > %zu", msp.min_young_size(), expected));
   }
 
-  static void verify_gen0_initial(size_t expected) {
+  static void verify_young_initial(size_t expected) {
     MarkSweepPolicy msp;
     msp.initialize_all();
 
-    assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
+    assert(msp.initial_young_size() == expected, err_msg("%zu != %zu", msp.initial_young_size(), expected));
   }
 
-  static void verify_scaled_gen0_initial(size_t initial_heap_size) {
+  static void verify_scaled_young_initial(size_t initial_heap_size) {
     MarkSweepPolicy msp;
     msp.initialize_all();
 
     size_t expected = msp.scale_by_NewRatio_aligned(initial_heap_size);
-    assert(msp.initial_gen0_size() == expected, err_msg("%zu != %zu", msp.initial_gen0_size(), expected));
+    assert(msp.initial_young_size() == expected, err_msg("%zu != %zu", msp.initial_young_size(), expected));
     assert(FLAG_IS_ERGO(NewSize) && NewSize == expected,
         err_msg("NewSize should have been set ergonomically to %zu, but was %zu", expected, NewSize));
   }
 
-  static void verify_gen1_min(size_t expected) {
+  static void verify_old_min(size_t expected) {
     MarkSweepPolicy msp;
     msp.initialize_all();
 
-    assert(msp.min_gen1_size() <= expected, err_msg("%zu  > %zu", msp.min_gen1_size(), expected));
+    assert(msp.min_old_size() <= expected, err_msg("%zu  > %zu", msp.min_old_size(), expected));
   }
 
-  static void verify_gen1_initial(size_t expected) {
+  static void verify_old_initial(size_t expected) {
     MarkSweepPolicy msp;
     msp.initialize_all();
 
-    assert(msp.initial_gen1_size() == expected, err_msg("%zu != %zu", msp.initial_gen1_size(), expected));
+    assert(msp.initial_old_size() == expected, err_msg("%zu != %zu", msp.initial_old_size(), expected));
   }
 
 
--- a/src/share/vm/memory/collectorPolicy.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/memory/collectorPolicy.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -219,12 +219,12 @@
 class GenCollectorPolicy : public CollectorPolicy {
 friend class TestGenCollectorPolicy;
  protected:
-  size_t _min_gen0_size;
-  size_t _initial_gen0_size;
-  size_t _max_gen0_size;
-  size_t _min_gen1_size;
-  size_t _initial_gen1_size;
-  size_t _max_gen1_size;
+  size_t _min_young_size;
+  size_t _initial_young_size;
+  size_t _max_young_size;
+  size_t _min_old_size;
+  size_t _initial_old_size;
+  size_t _max_old_size;
 
   // _gen_alignment and _space_alignment will have the same value most of the
   // time. When using large pages they can differ.
@@ -260,13 +260,13 @@
   GenCollectorPolicy();
 
   // Accessors
-  size_t min_gen0_size()     { return _min_gen0_size; }
-  size_t initial_gen0_size() { return _initial_gen0_size; }
-  size_t max_gen0_size()     { return _max_gen0_size; }
-  size_t gen_alignment()     { return _gen_alignment; }
-  size_t min_gen1_size()     { return _min_gen1_size; }
-  size_t initial_gen1_size() { return _initial_gen1_size; }
-  size_t max_gen1_size()     { return _max_gen1_size; }
+  size_t min_young_size()     { return _min_young_size; }
+  size_t initial_young_size() { return _initial_young_size; }
+  size_t max_young_size()     { return _max_young_size; }
+  size_t gen_alignment()      { return _gen_alignment; }
+  size_t min_old_size()       { return _min_old_size; }
+  size_t initial_old_size()   { return _initial_old_size; }
+  size_t max_old_size()       { return _max_old_size; }
 
   int number_of_generations() { return 2; }
 
@@ -298,7 +298,7 @@
                                       size_t init_survivor_size);
 
   virtual void post_heap_initialize() {
-    assert(_max_gen0_size == MaxNewSize, "Should be taken care of by initialize_size_info");
+    assert(_max_young_size == MaxNewSize, "Should be taken care of by initialize_size_info");
   }
 
   BarrierSet::Name barrier_set_name()  { return BarrierSet::CardTableModRef; }
--- a/src/share/vm/memory/genCollectedHeap.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/memory/genCollectedHeap.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1119,10 +1119,10 @@
 }
 
 void GenCollectedHeap::print_tracing_info() const {
-  if (TraceGen0Time) {
+  if (TraceYoungGenTime) {
     get_gen(0)->print_summary_info();
   }
-  if (TraceGen1Time) {
+  if (TraceOldGenTime) {
     get_gen(1)->print_summary_info();
   }
 }
--- a/src/share/vm/memory/tenuredGeneration.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/memory/tenuredGeneration.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -67,10 +67,9 @@
   // Does a "full" (forced) collection invoked on this generation collect
   // all younger generations as well? Note that this is a
   // hack to allow the collection of the younger gen first if the flag is
-  // set. This is better than using th policy's should_collect_gen0_first()
-  // since that causes us to do an extra unnecessary pair of restart-&-stop-world.
+  // set.
   virtual bool full_collects_younger_generations() const {
-    return !CollectGen0First;
+    return !ScavengeBeforeFullGC;
   }
 
   virtual void gc_prologue(bool full);
--- a/src/share/vm/oops/cpCache.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/oops/cpCache.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -407,7 +407,7 @@
 
 
 oop ConstantPoolCacheEntry::appendix_if_resolved(constantPoolHandle cpool) {
-  if (is_f1_null() || !has_appendix())
+  if (!has_appendix())
     return NULL;
   const int ref_index = f2_as_index() + _indy_resolved_references_appendix_offset;
   objArrayOop resolved_references = cpool->resolved_references();
@@ -416,7 +416,7 @@
 
 
 oop ConstantPoolCacheEntry::method_type_if_resolved(constantPoolHandle cpool) {
-  if (is_f1_null() || !has_method_type())
+  if (!has_method_type())
     return NULL;
   const int ref_index = f2_as_index() + _indy_resolved_references_method_type_offset;
   objArrayOop resolved_references = cpool->resolved_references();
--- a/src/share/vm/oops/cpCache.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/oops/cpCache.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -348,8 +348,8 @@
   bool is_final() const                          { return (_flags & (1 << is_final_shift))          != 0; }
   bool is_forced_virtual() const                 { return (_flags & (1 << is_forced_virtual_shift)) != 0; }
   bool is_vfinal() const                         { return (_flags & (1 << is_vfinal_shift))         != 0; }
-  bool has_appendix() const                      { return (_flags & (1 << has_appendix_shift))      != 0; }
-  bool has_method_type() const                   { return (_flags & (1 << has_method_type_shift))   != 0; }
+  bool has_appendix() const                      { return (!is_f1_null()) && (_flags & (1 << has_appendix_shift))      != 0; }
+  bool has_method_type() const                   { return (!is_f1_null()) && (_flags & (1 << has_method_type_shift))   != 0; }
   bool is_method_entry() const                   { return (_flags & (1 << is_field_entry_shift))    == 0; }
   bool is_field_entry() const                    { return (_flags & (1 << is_field_entry_shift))    != 0; }
   bool is_byte() const                           { return flag_state() == btos; }
--- a/src/share/vm/oops/methodData.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/oops/methodData.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -2053,7 +2053,7 @@
 
   // Whole-method sticky bits and flags
   enum {
-    _trap_hist_limit    = 20,   // decoupled from Deoptimization::Reason_LIMIT
+    _trap_hist_limit    = 21,   // decoupled from Deoptimization::Reason_LIMIT
     _trap_hist_mask     = max_jubyte,
     _extra_data_count   = 4     // extra DataLayout headers, for trap history
   }; // Public flag values
--- a/src/share/vm/opto/addnode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/addnode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -254,47 +254,46 @@
     const Type *t_sub1 = phase->type( in1->in(1) );
     const Type *t_2    = phase->type( in2        );
     if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP )
-      return new (phase->C) SubINode(phase->makecon( add_ring( t_sub1, t_2 ) ),
-                              in1->in(2) );
+      return new SubINode(phase->makecon( add_ring( t_sub1, t_2 ) ), in1->in(2) );
     // Convert "(a-b)+(c-d)" into "(a+c)-(b+d)"
     if( op2 == Op_SubI ) {
       // Check for dead cycle: d = (a-b)+(c-d)
       assert( in1->in(2) != this && in2->in(2) != this,
               "dead loop in AddINode::Ideal" );
-      Node *sub  = new (phase->C) SubINode(NULL, NULL);
-      sub->init_req(1, phase->transform(new (phase->C) AddINode(in1->in(1), in2->in(1) ) ));
-      sub->init_req(2, phase->transform(new (phase->C) AddINode(in1->in(2), in2->in(2) ) ));
+      Node *sub  = new SubINode(NULL, NULL);
+      sub->init_req(1, phase->transform(new AddINode(in1->in(1), in2->in(1) ) ));
+      sub->init_req(2, phase->transform(new AddINode(in1->in(2), in2->in(2) ) ));
       return sub;
     }
     // Convert "(a-b)+(b+c)" into "(a+c)"
     if( op2 == Op_AddI && in1->in(2) == in2->in(1) ) {
       assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal");
-      return new (phase->C) AddINode(in1->in(1), in2->in(2));
+      return new AddINode(in1->in(1), in2->in(2));
     }
     // Convert "(a-b)+(c+b)" into "(a+c)"
     if( op2 == Op_AddI && in1->in(2) == in2->in(2) ) {
       assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddINode::Ideal");
-      return new (phase->C) AddINode(in1->in(1), in2->in(1));
+      return new AddINode(in1->in(1), in2->in(1));
     }
     // Convert "(a-b)+(b-c)" into "(a-c)"
     if( op2 == Op_SubI && in1->in(2) == in2->in(1) ) {
       assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddINode::Ideal");
-      return new (phase->C) SubINode(in1->in(1), in2->in(2));
+      return new SubINode(in1->in(1), in2->in(2));
     }
     // Convert "(a-b)+(c-a)" into "(c-b)"
     if( op2 == Op_SubI && in1->in(1) == in2->in(2) ) {
       assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddINode::Ideal");
-      return new (phase->C) SubINode(in2->in(1), in1->in(2));
+      return new SubINode(in2->in(1), in1->in(2));
     }
   }
 
   // Convert "x+(0-y)" into "(x-y)"
   if( op2 == Op_SubI && phase->type(in2->in(1)) == TypeInt::ZERO )
-    return new (phase->C) SubINode(in1, in2->in(2) );
+    return new SubINode(in1, in2->in(2) );
 
   // Convert "(0-y)+x" into "(x-y)"
   if( op1 == Op_SubI && phase->type(in1->in(1)) == TypeInt::ZERO )
-    return new (phase->C) SubINode( in2, in1->in(2) );
+    return new SubINode( in2, in1->in(2) );
 
   // Convert (x>>>z)+y into (x+(y<<z))>>>z for small constant z and y.
   // Helps with array allocation math constant folding
@@ -315,8 +314,8 @@
     if( z < 5 && -5 < y && y < 0 ) {
       const Type *t_in11 = phase->type(in1->in(1));
       if( t_in11 != Type::TOP && (t_in11->is_int()->_lo >= -(y << z)) ) {
-        Node *a = phase->transform( new (phase->C) AddINode( in1->in(1), phase->intcon(y<<z) ) );
-        return new (phase->C) URShiftINode( a, in1->in(2) );
+        Node *a = phase->transform( new AddINode( in1->in(1), phase->intcon(y<<z) ) );
+        return new URShiftINode( a, in1->in(2) );
       }
     }
   }
@@ -387,47 +386,46 @@
     const Type *t_sub1 = phase->type( in1->in(1) );
     const Type *t_2    = phase->type( in2        );
     if( t_sub1->singleton() && t_2->singleton() && t_sub1 != Type::TOP && t_2 != Type::TOP )
-      return new (phase->C) SubLNode(phase->makecon( add_ring( t_sub1, t_2 ) ),
-                              in1->in(2) );
+      return new SubLNode(phase->makecon( add_ring( t_sub1, t_2 ) ), in1->in(2) );
     // Convert "(a-b)+(c-d)" into "(a+c)-(b+d)"
     if( op2 == Op_SubL ) {
       // Check for dead cycle: d = (a-b)+(c-d)
       assert( in1->in(2) != this && in2->in(2) != this,
               "dead loop in AddLNode::Ideal" );
-      Node *sub  = new (phase->C) SubLNode(NULL, NULL);
-      sub->init_req(1, phase->transform(new (phase->C) AddLNode(in1->in(1), in2->in(1) ) ));
-      sub->init_req(2, phase->transform(new (phase->C) AddLNode(in1->in(2), in2->in(2) ) ));
+      Node *sub  = new SubLNode(NULL, NULL);
+      sub->init_req(1, phase->transform(new AddLNode(in1->in(1), in2->in(1) ) ));
+      sub->init_req(2, phase->transform(new AddLNode(in1->in(2), in2->in(2) ) ));
       return sub;
     }
     // Convert "(a-b)+(b+c)" into "(a+c)"
     if( op2 == Op_AddL && in1->in(2) == in2->in(1) ) {
       assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal");
-      return new (phase->C) AddLNode(in1->in(1), in2->in(2));
+      return new AddLNode(in1->in(1), in2->in(2));
     }
     // Convert "(a-b)+(c+b)" into "(a+c)"
     if( op2 == Op_AddL && in1->in(2) == in2->in(2) ) {
       assert(in1->in(1) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal");
-      return new (phase->C) AddLNode(in1->in(1), in2->in(1));
+      return new AddLNode(in1->in(1), in2->in(1));
     }
     // Convert "(a-b)+(b-c)" into "(a-c)"
     if( op2 == Op_SubL && in1->in(2) == in2->in(1) ) {
       assert(in1->in(1) != this && in2->in(2) != this,"dead loop in AddLNode::Ideal");
-      return new (phase->C) SubLNode(in1->in(1), in2->in(2));
+      return new SubLNode(in1->in(1), in2->in(2));
     }
     // Convert "(a-b)+(c-a)" into "(c-b)"
     if( op2 == Op_SubL && in1->in(1) == in1->in(2) ) {
       assert(in1->in(2) != this && in2->in(1) != this,"dead loop in AddLNode::Ideal");
-      return new (phase->C) SubLNode(in2->in(1), in1->in(2));
+      return new SubLNode(in2->in(1), in1->in(2));
     }
   }
 
   // Convert "x+(0-y)" into "(x-y)"
   if( op2 == Op_SubL && phase->type(in2->in(1)) == TypeLong::ZERO )
-    return new (phase->C) SubLNode( in1, in2->in(2) );
+    return new SubLNode( in1, in2->in(2) );
 
   // Convert "(0-y)+x" into "(x-y)"
   if( op1 == Op_SubL && phase->type(in1->in(1)) == TypeInt::ZERO )
-    return new (phase->C) SubLNode( in2, in1->in(2) );
+    return new SubLNode( in2, in1->in(2) );
 
   // Convert "X+X+X+X+X...+X+Y" into "k*X+Y" or really convert "X+(X+Y)"
   // into "(X<<1)+Y" and let shift-folding happen.
@@ -435,8 +433,8 @@
       in2->in(1) == in1 &&
       op1 != Op_ConL &&
       0 ) {
-    Node *shift = phase->transform(new (phase->C) LShiftLNode(in1,phase->intcon(1)));
-    return new (phase->C) AddLNode(shift,in2->in(2));
+    Node *shift = phase->transform(new LShiftLNode(in1,phase->intcon(1)));
+    return new AddLNode(shift,in2->in(2));
   }
 
   return AddNode::Ideal(phase, can_reshape);
@@ -596,7 +594,7 @@
         offset  = phase->MakeConX(t2->get_con() + t12->get_con());
       } else {
         // Else move the constant to the right.  ((A+con)+B) into ((A+B)+con)
-        address = phase->transform(new (phase->C) AddPNode(in(Base),addp->in(Address),in(Offset)));
+        address = phase->transform(new AddPNode(in(Base),addp->in(Address),in(Offset)));
         offset  = addp->in(Offset);
       }
       PhaseIterGVN *igvn = phase->is_IterGVN();
@@ -616,7 +614,7 @@
     // If this is a NULL+long form (from unsafe accesses), switch to a rawptr.
     if (phase->type(in(Address)) == TypePtr::NULL_PTR) {
       Node* offset = in(Offset);
-      return new (phase->C) CastX2PNode(offset);
+      return new CastX2PNode(offset);
     }
   }
 
@@ -628,7 +626,7 @@
   if( add->Opcode() == Op_AddX && add->in(1) != add ) {
     const Type *t22 = phase->type( add->in(2) );
     if( t22->singleton() && (t22 != Type::TOP) ) {  // Right input is an add of a constant?
-      set_req(Address, phase->transform(new (phase->C) AddPNode(in(Base),in(Address),add->in(1))));
+      set_req(Address, phase->transform(new AddPNode(in(Base),in(Address),add->in(1))));
       set_req(Offset, add->in(2));
       PhaseIterGVN *igvn = phase->is_IterGVN();
       if (add->outcnt() == 0 && igvn) {
@@ -858,7 +856,7 @@
   // to force a right-spline graph for the rest of MinINode::Ideal().
   if( l->Opcode() == Op_MinI ) {
     assert( l != l->in(1), "dead loop in MinINode::Ideal" );
-    r = phase->transform(new (phase->C) MinINode(l->in(2),r));
+    r = phase->transform(new MinINode(l->in(2),r));
     l = l->in(1);
     set_req(1, l);
     set_req(2, r);
@@ -906,18 +904,18 @@
     }
 
     if( x->_idx > y->_idx )
-      return new (phase->C) MinINode(r->in(1),phase->transform(new (phase->C) MinINode(l,r->in(2))));
+      return new MinINode(r->in(1),phase->transform(new MinINode(l,r->in(2))));
 
     // See if covers: MIN2(x+c0,MIN2(y+c1,z))
     if( !phase->eqv(x,y) ) return NULL;
     // If (y == x) transform MIN2(x+c0, MIN2(x+c1,z)) into
     // MIN2(x+c0 or x+c1 which less, z).
-    return new (phase->C) MinINode(phase->transform(new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off)))),r->in(2));
+    return new MinINode(phase->transform(new AddINode(x,phase->intcon(MIN2(x_off,y_off)))),r->in(2));
   } else {
     // See if covers: MIN2(x+c0,y+c1)
     if( !phase->eqv(x,y) ) return NULL;
     // If (y == x) transform MIN2(x+c0,x+c1) into x+c0 or x+c1 which less.
-    return new (phase->C) AddINode(x,phase->intcon(MIN2(x_off,y_off)));
+    return new AddINode(x,phase->intcon(MIN2(x_off,y_off)));
   }
 
 }
--- a/src/share/vm/opto/block.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/block.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -373,7 +373,7 @@
   // I'll need a few machine-specific GotoNodes.  Make an Ideal GotoNode,
   // then Match it into a machine-specific Node.  Then clone the machine
   // Node on demand.
-  Node *x = new (C) GotoNode(NULL);
+  Node *x = new GotoNode(NULL);
   x->init_req(0, x);
   _goto = matcher.match_tree(x);
   assert(_goto != NULL, "");
@@ -426,7 +426,7 @@
                !p->is_block_start() );
       // Make the block begin with one of Region or StartNode.
       if( !p->is_block_start() ) {
-        RegionNode *r = new (C) RegionNode( 2 );
+        RegionNode *r = new RegionNode( 2 );
         r->init_req(1, p);         // Insert RegionNode in the way
         proj->set_req(0, r);        // Insert RegionNode in the way
         p = r;
@@ -501,7 +501,7 @@
   // get ProjNode corresponding to the succ_no'th successor of the in block
   ProjNode* proj = in->get_node(in->number_of_nodes() - in->_num_succs + succ_no)->as_Proj();
   // create region for basic block
-  RegionNode* region = new (C) RegionNode(2);
+  RegionNode* region = new RegionNode(2);
   region->init_req(1, proj);
   // setup corresponding basic block
   Block* block = new (_block_arena) Block(_block_arena, region);
--- a/src/share/vm/opto/bytecodeInfo.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/bytecodeInfo.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -361,11 +361,14 @@
     set_msg("not an accessor");
     return false;
   }
+
+  // Limit inlining depth in case inlining is forced or
+  // _max_inline_level was increased to compensate for lambda forms.
+  if (inline_level() > MaxForceInlineLevel) {
+    set_msg("MaxForceInlineLevel");
+    return false;
+  }
   if (inline_level() > _max_inline_level) {
-    if (callee_method->force_inline() && inline_level() > MaxForceInlineLevel) {
-      set_msg("MaxForceInlineLevel");
-      return false;
-    }
     if (!callee_method->force_inline() || !IncrementalInline) {
       set_msg("inlining too deep");
       return false;
--- a/src/share/vm/opto/c2_globals.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/c2_globals.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -650,9 +650,6 @@
   product(bool, UseMathExactIntrinsics, true,                               \
           "Enables intrinsification of various java.lang.Math functions")   \
                                                                             \
-  experimental(bool, ReplaceInParentMaps, false,                            \
-          "Propagate type improvements in callers of inlinee if possible")  \
-                                                                            \
   product(bool, UseTypeSpeculation, true,                                   \
           "Speculatively propagate types from profiles")                    \
                                                                             \
--- a/src/share/vm/opto/callGenerator.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/callGenerator.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -63,12 +63,12 @@
   }
 
   virtual bool      is_parse() const           { return true; }
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
+  virtual JVMState* generate(JVMState* jvms);
   int is_osr() { return _is_osr; }
 
 };
 
-JVMState* ParseGenerator::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* ParseGenerator::generate(JVMState* jvms) {
   Compile* C = Compile::current();
   C->print_inlining_update(this);
 
@@ -81,7 +81,7 @@
     return NULL;  // bailing out of the compile; do not try to parse
   }
 
-  Parse parser(jvms, method(), _expected_uses, parent_parser);
+  Parse parser(jvms, method(), _expected_uses);
   // Grab signature for matching/allocation
 #ifdef ASSERT
   if (parser.tf() != (parser.depth() == 1 ? C->tf() : tf())) {
@@ -120,12 +120,12 @@
       _separate_io_proj(separate_io_proj)
   {
   }
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
+  virtual JVMState* generate(JVMState* jvms);
 
   CallStaticJavaNode* call_node() const { return _call_node; }
 };
 
-JVMState* DirectCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* DirectCallGenerator::generate(JVMState* jvms) {
   GraphKit kit(jvms);
   kit.C->print_inlining_update(this);
   bool is_static = method()->is_static();
@@ -136,7 +136,7 @@
     kit.C->log()->elem("direct_call bci='%d'", jvms->bci());
   }
 
-  CallStaticJavaNode *call = new (kit.C) CallStaticJavaNode(kit.C, tf(), target, method(), kit.bci());
+  CallStaticJavaNode *call = new CallStaticJavaNode(kit.C, tf(), target, method(), kit.bci());
   _call_node = call;  // Save the call node in case we need it later
   if (!is_static) {
     // Make an explicit receiver null_check as part of this call.
@@ -173,10 +173,10 @@
            vtable_index >= 0, "either invalid or usable");
   }
   virtual bool      is_virtual() const          { return true; }
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
+  virtual JVMState* generate(JVMState* jvms);
 };
 
-JVMState* VirtualCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* VirtualCallGenerator::generate(JVMState* jvms) {
   GraphKit kit(jvms);
   Node* receiver = kit.argument(0);
 
@@ -225,7 +225,7 @@
          "no vtable calls if +UseInlineCaches ");
   address target = SharedRuntime::get_resolve_virtual_call_stub();
   // Normal inline cache used for call
-  CallDynamicJavaNode *call = new (kit.C) CallDynamicJavaNode(tf(), target, method(), _vtable_index, kit.bci());
+  CallDynamicJavaNode *call = new CallDynamicJavaNode(tf(), target, method(), _vtable_index, kit.bci());
   kit.set_arguments_for_java_call(call);
   kit.set_edges_for_java_call(call);
   Node* ret = kit.set_results_for_java_call(call);
@@ -283,7 +283,7 @@
   // Convert the CallStaticJava into an inline
   virtual void do_late_inline();
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
+  virtual JVMState* generate(JVMState* jvms) {
     Compile *C = Compile::current();
 
     C->log_inline_id(this);
@@ -298,7 +298,7 @@
     // that the late inlining logic can distinguish between fall
     // through and exceptional uses of the memory and io projections
     // as is done for allocations and macro expansion.
-    return DirectCallGenerator::generate(jvms, parent_parser);
+    return DirectCallGenerator::generate(jvms);
   }
 
   virtual void print_inlining_late(const char* msg) {
@@ -350,7 +350,7 @@
   JVMState* old_jvms = call->jvms();
   JVMState* jvms = old_jvms->clone_shallow(C);
   uint size = call->req();
-  SafePointNode* map = new (C) SafePointNode(size, jvms);
+  SafePointNode* map = new SafePointNode(size, jvms);
   for (uint i1 = 0; i1 < size; i1++) {
     map->init_req(i1, call->in(i1));
   }
@@ -399,7 +399,7 @@
   }
 
   // Now perform the inlining using the synthesized JVMState
-  JVMState* new_jvms = _inline_cg->generate(jvms, NULL);
+  JVMState* new_jvms = _inline_cg->generate(jvms);
   if (new_jvms == NULL)  return;  // no change
   if (C->failing())      return;
 
@@ -417,7 +417,7 @@
   C->env()->notice_inlined_method(_inline_cg->method());
   C->set_inlining_progress(true);
 
-  kit.replace_call(call, result);
+  kit.replace_call(call, result, true);
 }
 
 
@@ -439,8 +439,8 @@
 
   virtual bool is_mh_late_inline() const { return true; }
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
-    JVMState* new_jvms = LateInlineCallGenerator::generate(jvms, parent_parser);
+  virtual JVMState* generate(JVMState* jvms) {
+    JVMState* new_jvms = LateInlineCallGenerator::generate(jvms);
 
     Compile* C = Compile::current();
     if (_input_not_const) {
@@ -486,14 +486,14 @@
   LateInlineStringCallGenerator(ciMethod* method, CallGenerator* inline_cg) :
     LateInlineCallGenerator(method, inline_cg) {}
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
+  virtual JVMState* generate(JVMState* jvms) {
     Compile *C = Compile::current();
 
     C->log_inline_id(this);
 
     C->add_string_late_inline(this);
 
-    JVMState* new_jvms =  DirectCallGenerator::generate(jvms, parent_parser);
+    JVMState* new_jvms =  DirectCallGenerator::generate(jvms);
     return new_jvms;
   }
 
@@ -510,14 +510,14 @@
   LateInlineBoxingCallGenerator(ciMethod* method, CallGenerator* inline_cg) :
     LateInlineCallGenerator(method, inline_cg) {}
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) {
+  virtual JVMState* generate(JVMState* jvms) {
     Compile *C = Compile::current();
 
     C->log_inline_id(this);
 
     C->add_boxing_late_inline(this);
 
-    JVMState* new_jvms =  DirectCallGenerator::generate(jvms, parent_parser);
+    JVMState* new_jvms =  DirectCallGenerator::generate(jvms);
     return new_jvms;
   }
 };
@@ -553,7 +553,7 @@
   virtual bool      is_virtual() const          { return _is_virtual; }
   virtual bool      is_deferred() const         { return true; }
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
+  virtual JVMState* generate(JVMState* jvms);
 };
 
 
@@ -563,14 +563,14 @@
   return new WarmCallGenerator(ci, if_cold, if_hot);
 }
 
-JVMState* WarmCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* WarmCallGenerator::generate(JVMState* jvms) {
   Compile* C = Compile::current();
   C->print_inlining_update(this);
 
   if (C->log() != NULL) {
     C->log()->elem("warm_call bci='%d'", jvms->bci());
   }
-  jvms = _if_cold->generate(jvms, parent_parser);
+  jvms = _if_cold->generate(jvms);
   if (jvms != NULL) {
     Node* m = jvms->map()->control();
     if (m->is_CatchProj()) m = m->in(0);  else m = C->top();
@@ -631,7 +631,7 @@
   virtual bool      is_inline()    const    { return _if_hit->is_inline(); }
   virtual bool      is_deferred()  const    { return _if_hit->is_deferred(); }
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
+  virtual JVMState* generate(JVMState* jvms);
 };
 
 
@@ -643,14 +643,13 @@
 }
 
 
-JVMState* PredictedCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* PredictedCallGenerator::generate(JVMState* jvms) {
   GraphKit kit(jvms);
   kit.C->print_inlining_update(this);
   PhaseGVN& gvn = kit.gvn();
   // We need an explicit receiver null_check before checking its type.
   // We share a map with the caller, so his JVMS gets adjusted.
   Node* receiver = kit.argument(0);
-
   CompileLog* log = kit.C->log();
   if (log != NULL) {
     log->elem("predicted_call bci='%d' klass='%d'",
@@ -662,6 +661,10 @@
     return kit.transfer_exceptions_into_jvms();
   }
 
+  // Make a copy of the replaced nodes in case we need to restore them
+  ReplacedNodes replaced_nodes = kit.map()->replaced_nodes();
+  replaced_nodes.clone();
+
   Node* exact_receiver = receiver;  // will get updated in place...
   Node* slow_ctl = kit.type_check_receiver(receiver,
                                            _predicted_receiver, _hit_prob,
@@ -672,7 +675,7 @@
   { PreserveJVMState pjvms(&kit);
     kit.set_control(slow_ctl);
     if (!kit.stopped()) {
-      slow_jvms = _if_missed->generate(kit.sync_jvms(), parent_parser);
+      slow_jvms = _if_missed->generate(kit.sync_jvms());
       if (kit.failing())
         return NULL;  // might happen because of NodeCountInliningCutoff
       assert(slow_jvms != NULL, "must be");
@@ -693,12 +696,12 @@
   kit.replace_in_map(receiver, exact_receiver);
 
   // Make the hot call:
-  JVMState* new_jvms = _if_hit->generate(kit.sync_jvms(), parent_parser);
+  JVMState* new_jvms = _if_hit->generate(kit.sync_jvms());
   if (new_jvms == NULL) {
     // Inline failed, so make a direct call.
     assert(_if_hit->is_inline(), "must have been a failed inline");
     CallGenerator* cg = CallGenerator::for_direct_call(_if_hit->method());
-    new_jvms = cg->generate(kit.sync_jvms(), parent_parser);
+    new_jvms = cg->generate(kit.sync_jvms());
   }
   kit.add_exception_states_from(new_jvms);
   kit.set_jvms(new_jvms);
@@ -715,16 +718,29 @@
     return kit.transfer_exceptions_into_jvms();
   }
 
+  // There are 2 branches and the replaced nodes are only valid on
+  // one: restore the replaced nodes to what they were before the
+  // branch.
+  kit.map()->set_replaced_nodes(replaced_nodes);
+
   // Finish the diamond.
   kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
-  RegionNode* region = new (kit.C) RegionNode(3);
+  RegionNode* region = new RegionNode(3);
   region->init_req(1, kit.control());
   region->init_req(2, slow_map->control());
   kit.set_control(gvn.transform(region));
   Node* iophi = PhiNode::make(region, kit.i_o(), Type::ABIO);
   iophi->set_req(2, slow_map->i_o());
   kit.set_i_o(gvn.transform(iophi));
+  // Merge memory
   kit.merge_memory(slow_map->merged_memory(), region, 2);
+  // Transform new memory Phis.
+  for (MergeMemStream mms(kit.merged_memory()); mms.next_non_empty();) {
+    Node* phi = mms.memory();
+    if (phi->is_Phi() && phi->in(0) == region) {
+      mms.set_memory(gvn.transform(phi));
+    }
+  }
   uint tos = kit.jvms()->stkoff() + kit.sp();
   uint limit = slow_map->req();
   for (uint i = TypeFunc::Parms; i < limit; i++) {
@@ -825,7 +841,7 @@
           const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
           const Type*       sig_type = TypeOopPtr::make_from_klass(signature->accessing_klass());
           if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
-            Node* cast_obj = gvn.transform(new (C) CheckCastPPNode(kit.control(), arg, sig_type));
+            Node* cast_obj = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
             kit.set_argument(0, cast_obj);
           }
         }
@@ -837,7 +853,7 @@
             const TypeOopPtr* arg_type = arg->bottom_type()->isa_oopptr();
             const Type*       sig_type = TypeOopPtr::make_from_klass(t->as_klass());
             if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
-              Node* cast_obj = gvn.transform(new (C) CheckCastPPNode(kit.control(), arg, sig_type));
+              Node* cast_obj = gvn.transform(new CheckCastPPNode(kit.control(), arg, sig_type));
               kit.set_argument(receiver_skip + i, cast_obj);
             }
           }
@@ -882,15 +898,15 @@
 }
 
 
-//------------------------PredictedIntrinsicGenerator------------------------------
-// Internal class which handles all predicted Intrinsic calls.
-class PredictedIntrinsicGenerator : public CallGenerator {
+//------------------------PredicatedIntrinsicGenerator------------------------------
+// Internal class which handles all predicated Intrinsic calls.
+class PredicatedIntrinsicGenerator : public CallGenerator {
   CallGenerator* _intrinsic;
   CallGenerator* _cg;
 
 public:
-  PredictedIntrinsicGenerator(CallGenerator* intrinsic,
-                              CallGenerator* cg)
+  PredicatedIntrinsicGenerator(CallGenerator* intrinsic,
+                               CallGenerator* cg)
     : CallGenerator(cg->method())
   {
     _intrinsic = intrinsic;
@@ -901,108 +917,186 @@
   virtual bool      is_inlined()   const    { return true; }
   virtual bool      is_intrinsic() const    { return true; }
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
+  virtual JVMState* generate(JVMState* jvms);
 };
 
 
-CallGenerator* CallGenerator::for_predicted_intrinsic(CallGenerator* intrinsic,
-                                                      CallGenerator* cg) {
-  return new PredictedIntrinsicGenerator(intrinsic, cg);
+CallGenerator* CallGenerator::for_predicated_intrinsic(CallGenerator* intrinsic,
+                                                       CallGenerator* cg) {
+  return new PredicatedIntrinsicGenerator(intrinsic, cg);
 }
 
 
-JVMState* PredictedIntrinsicGenerator::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* PredicatedIntrinsicGenerator::generate(JVMState* jvms) {
+  // The code we want to generate here is:
+  //    if (receiver == NULL)
+  //        uncommon_Trap
+  //    if (predicate(0))
+  //        do_intrinsic(0)
+  //    else
+  //    if (predicate(1))
+  //        do_intrinsic(1)
+  //    ...
+  //    else
+  //        do_java_comp
+
   GraphKit kit(jvms);
   PhaseGVN& gvn = kit.gvn();
 
   CompileLog* log = kit.C->log();
   if (log != NULL) {
-    log->elem("predicted_intrinsic bci='%d' method='%d'",
+    log->elem("predicated_intrinsic bci='%d' method='%d'",
               jvms->bci(), log->identify(method()));
   }
 
-  Node* slow_ctl = _intrinsic->generate_predicate(kit.sync_jvms());
-  if (kit.failing())
-    return NULL;  // might happen because of NodeCountInliningCutoff
-
-  kit.C->print_inlining_update(this);
-  SafePointNode* slow_map = NULL;
-  JVMState* slow_jvms;
-  if (slow_ctl != NULL) {
-    PreserveJVMState pjvms(&kit);
-    kit.set_control(slow_ctl);
-    if (!kit.stopped()) {
-      slow_jvms = _cg->generate(kit.sync_jvms(), parent_parser);
-      if (kit.failing())
-        return NULL;  // might happen because of NodeCountInliningCutoff
-      assert(slow_jvms != NULL, "must be");
-      kit.add_exception_states_from(slow_jvms);
-      kit.set_map(slow_jvms->map());
-      if (!kit.stopped())
-        slow_map = kit.stop();
+  if (!method()->is_static()) {
+    // We need an explicit receiver null_check before checking its type in predicate.
+    // We share a map with the caller, so his JVMS gets adjusted.
+    Node* receiver = kit.null_check_receiver_before_call(method());
+    if (kit.stopped()) {
+      return kit.transfer_exceptions_into_jvms();
     }
   }
 
-  if (kit.stopped()) {
-    // Predicate is always false.
-    kit.set_jvms(slow_jvms);
+  int n_predicates = _intrinsic->predicates_count();
+  assert(n_predicates > 0, "sanity");
+
+  JVMState** result_jvms = NEW_RESOURCE_ARRAY(JVMState*, (n_predicates+1));
+
+  // Region for normal compilation code if intrinsic failed.
+  Node* slow_region = new RegionNode(1);
+
+  int results = 0;
+  for (int predicate = 0; (predicate < n_predicates) && !kit.stopped(); predicate++) {
+#ifdef ASSERT
+    JVMState* old_jvms = kit.jvms();
+    SafePointNode* old_map = kit.map();
+    Node* old_io  = old_map->i_o();
+    Node* old_mem = old_map->memory();
+    Node* old_exc = old_map->next_exception();
+#endif
+    Node* else_ctrl = _intrinsic->generate_predicate(kit.sync_jvms(), predicate);
+#ifdef ASSERT
+    // Assert(no_new_memory && no_new_io && no_new_exceptions) after generate_predicate.
+    assert(old_jvms == kit.jvms(), "generate_predicate should not change jvm state");
+    SafePointNode* new_map = kit.map();
+    assert(old_io  == new_map->i_o(), "generate_predicate should not change i_o");
+    assert(old_mem == new_map->memory(), "generate_predicate should not change memory");
+    assert(old_exc == new_map->next_exception(), "generate_predicate should not add exceptions");
+#endif
+    if (!kit.stopped()) {
+      PreserveJVMState pjvms(&kit);
+      // Generate intrinsic code:
+      JVMState* new_jvms = _intrinsic->generate(kit.sync_jvms());
+      if (new_jvms == NULL) {
+        // Intrinsic failed, use normal compilation path for this predicate.
+        slow_region->add_req(kit.control());
+      } else {
+        kit.add_exception_states_from(new_jvms);
+        kit.set_jvms(new_jvms);
+        if (!kit.stopped()) {
+          result_jvms[results++] = kit.jvms();
+        }
+      }
+    }
+    if (else_ctrl == NULL) {
+      else_ctrl = kit.C->top();
+    }
+    kit.set_control(else_ctrl);
+  }
+  if (!kit.stopped()) {
+    // Final 'else' after predicates.
+    slow_region->add_req(kit.control());
+  }
+  if (slow_region->req() > 1) {
+    PreserveJVMState pjvms(&kit);
+    // Generate normal compilation code:
+    kit.set_control(gvn.transform(slow_region));
+    JVMState* new_jvms = _cg->generate(kit.sync_jvms());
+    if (kit.failing())
+      return NULL;  // might happen because of NodeCountInliningCutoff
+    assert(new_jvms != NULL, "must be");
+    kit.add_exception_states_from(new_jvms);
+    kit.set_jvms(new_jvms);
+    if (!kit.stopped()) {
+      result_jvms[results++] = kit.jvms();
+    }
+  }
+
+  if (results == 0) {
+    // All paths ended in uncommon traps.
+    (void) kit.stop();
     return kit.transfer_exceptions_into_jvms();
   }
 
-  // Generate intrinsic code:
-  JVMState* new_jvms = _intrinsic->generate(kit.sync_jvms(), parent_parser);
-  if (new_jvms == NULL) {
-    // Intrinsic failed, so use slow code or make a direct call.
-    if (slow_map == NULL) {
-      CallGenerator* cg = CallGenerator::for_direct_call(method());
-      new_jvms = cg->generate(kit.sync_jvms(), parent_parser);
-    } else {
-      kit.set_jvms(slow_jvms);
-      return kit.transfer_exceptions_into_jvms();
-    }
-  }
-  kit.add_exception_states_from(new_jvms);
-  kit.set_jvms(new_jvms);
-
-  // Need to merge slow and fast?
-  if (slow_map == NULL) {
-    // The fast path is the only path remaining.
+  if (results == 1) { // Only one path
+    kit.set_jvms(result_jvms[0]);
     return kit.transfer_exceptions_into_jvms();
   }
 
-  if (kit.stopped()) {
-    // Intrinsic method threw an exception, so it's just the slow path after all.
-    kit.set_jvms(slow_jvms);
-    return kit.transfer_exceptions_into_jvms();
+  // Merge all paths.
+  kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
+  RegionNode* region = new RegionNode(results + 1);
+  Node* iophi = PhiNode::make(region, kit.i_o(), Type::ABIO);
+  for (int i = 0; i < results; i++) {
+    JVMState* jvms = result_jvms[i];
+    int path = i + 1;
+    SafePointNode* map = jvms->map();
+    region->init_req(path, map->control());
+    iophi->set_req(path, map->i_o());
+    if (i == 0) {
+      kit.set_jvms(jvms);
+    } else {
+      kit.merge_memory(map->merged_memory(), region, path);
+    }
+  }
+  kit.set_control(gvn.transform(region));
+  kit.set_i_o(gvn.transform(iophi));
+  // Transform new memory Phis.
+  for (MergeMemStream mms(kit.merged_memory()); mms.next_non_empty();) {
+    Node* phi = mms.memory();
+    if (phi->is_Phi() && phi->in(0) == region) {
+      mms.set_memory(gvn.transform(phi));
+    }
   }
 
-  // Finish the diamond.
-  kit.C->set_has_split_ifs(true); // Has chance for split-if optimization
-  RegionNode* region = new (kit.C) RegionNode(3);
-  region->init_req(1, kit.control());
-  region->init_req(2, slow_map->control());
-  kit.set_control(gvn.transform(region));
-  Node* iophi = PhiNode::make(region, kit.i_o(), Type::ABIO);
-  iophi->set_req(2, slow_map->i_o());
-  kit.set_i_o(gvn.transform(iophi));
-  kit.merge_memory(slow_map->merged_memory(), region, 2);
+  // Merge debug info.
+  Node** ins = NEW_RESOURCE_ARRAY(Node*, results);
   uint tos = kit.jvms()->stkoff() + kit.sp();
-  uint limit = slow_map->req();
+  Node* map = kit.map();
+  uint limit = map->req();
   for (uint i = TypeFunc::Parms; i < limit; i++) {
     // Skip unused stack slots; fast forward to monoff();
     if (i == tos) {
       i = kit.jvms()->monoff();
       if( i >= limit ) break;
     }
-    Node* m = kit.map()->in(i);
-    Node* n = slow_map->in(i);
-    if (m != n) {
-      const Type* t = gvn.type(m)->meet_speculative(gvn.type(n));
-      Node* phi = PhiNode::make(region, m, t);
-      phi->set_req(2, n);
-      kit.map()->set_req(i, gvn.transform(phi));
+    Node* n = map->in(i);
+    ins[0] = n;
+    const Type* t = gvn.type(n);
+    bool needs_phi = false;
+    for (int j = 1; j < results; j++) {
+      JVMState* jvms = result_jvms[j];
+      Node* jmap = jvms->map();
+      Node* m = NULL;
+      if (jmap->req() > i) {
+        m = jmap->in(i);
+        if (m != n) {
+          needs_phi = true;
+          t = t->meet_speculative(gvn.type(m));
+        }
+      }
+      ins[j] = m;
+    }
+    if (needs_phi) {
+      Node* phi = PhiNode::make(region, n, t);
+      for (int j = 1; j < results; j++) {
+        phi->set_req(j + 1, ins[j]);
+      }
+      map->set_req(i, gvn.transform(phi));
     }
   }
+
   return kit.transfer_exceptions_into_jvms();
 }
 
@@ -1025,7 +1119,7 @@
   virtual bool      is_virtual() const          { ShouldNotReachHere(); return false; }
   virtual bool      is_trap() const             { return true; }
 
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
+  virtual JVMState* generate(JVMState* jvms);
 };
 
 
@@ -1037,7 +1131,7 @@
 }
 
 
-JVMState* UncommonTrapCallGenerator::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* UncommonTrapCallGenerator::generate(JVMState* jvms) {
   GraphKit kit(jvms);
   kit.C->print_inlining_update(this);
   // Take the trap with arguments pushed on the stack.  (Cf. null_check_receiver).
--- a/src/share/vm/opto/callGenerator.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/callGenerator.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -31,8 +31,6 @@
 #include "opto/type.hpp"
 #include "runtime/deoptimization.hpp"
 
-class Parse;
-
 //---------------------------CallGenerator-------------------------------------
 // The subclasses of this class handle generation of ideal nodes for
 // call sites and method entry points.
@@ -63,8 +61,9 @@
   virtual bool      is_virtual() const          { return false; }
   // is_deferred: The decision whether to inline or not is deferred.
   virtual bool      is_deferred() const         { return false; }
-  // is_predicted: Uses an explicit check against a predicted type.
-  virtual bool      is_predicted() const        { return false; }
+  // is_predicated: Uses an explicit check (predicate).
+  virtual bool      is_predicated() const       { return false; }
+  virtual int       predicates_count() const    { return 0; }
   // is_trap: Does not return to the caller.  (E.g., uncommon trap.)
   virtual bool      is_trap() const             { return false; }
   // does_virtual_dispatch: Should try inlining as normal method first.
@@ -114,7 +113,7 @@
   //
   // If the result is NULL, it means that this CallGenerator was unable
   // to handle the given call, and another CallGenerator should be consulted.
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser) = 0;
+  virtual JVMState* generate(JVMState* jvms) = 0;
 
   // How to generate a call site that is inlined:
   static CallGenerator* for_inline(ciMethod* m, float expected_uses = -1);
@@ -160,9 +159,9 @@
   // Registry for intrinsics:
   static CallGenerator* for_intrinsic(ciMethod* m);
   static void register_intrinsic(ciMethod* m, CallGenerator* cg);
-  static CallGenerator* for_predicted_intrinsic(CallGenerator* intrinsic,
-                                                CallGenerator* cg);
-  virtual Node* generate_predicate(JVMState* jvms) { return NULL; };
+  static CallGenerator* for_predicated_intrinsic(CallGenerator* intrinsic,
+                                                 CallGenerator* cg);
+  virtual Node* generate_predicate(JVMState* jvms, int predicate) { return NULL; };
 
   virtual void print_inlining_late(const char* msg) { ShouldNotReachHere(); }
 
--- a/src/share/vm/opto/callnode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/callnode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -74,20 +74,20 @@
   case TypeFunc::Control:
   case TypeFunc::I_O:
   case TypeFunc::Memory:
-    return new (match->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
+    return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
   case TypeFunc::FramePtr:
-    return new (match->C) MachProjNode(this,proj->_con,Matcher::c_frame_ptr_mask, Op_RegP);
+    return new MachProjNode(this,proj->_con,Matcher::c_frame_ptr_mask, Op_RegP);
   case TypeFunc::ReturnAdr:
-    return new (match->C) MachProjNode(this,proj->_con,match->_return_addr_mask,Op_RegP);
+    return new MachProjNode(this,proj->_con,match->_return_addr_mask,Op_RegP);
   case TypeFunc::Parms:
   default: {
       uint parm_num = proj->_con - TypeFunc::Parms;
       const Type *t = _domain->field_at(proj->_con);
       if (t->base() == Type::Half)  // 2nd half of Longs and Doubles
-        return new (match->C) ConNode(Type::TOP);
+        return new ConNode(Type::TOP);
       uint ideal_reg = t->ideal_reg();
       RegMask &rm = match->_calling_convention_mask[parm_num];
-      return new (match->C) MachProjNode(this,proj->_con,rm,ideal_reg);
+      return new MachProjNode(this,proj->_con,rm,ideal_reg);
     }
   }
   return NULL;
@@ -685,12 +685,12 @@
   case TypeFunc::Control:
   case TypeFunc::I_O:
   case TypeFunc::Memory:
-    return new (match->C) MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
+    return new MachProjNode(this,proj->_con,RegMask::Empty,MachProjNode::unmatched_proj);
 
   case TypeFunc::Parms+1:       // For LONG & DOUBLE returns
     assert(tf()->_range->field_at(TypeFunc::Parms+1) == Type::HALF, "");
     // 2nd half of doubles and longs
-    return new (match->C) MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad);
+    return new MachProjNode(this,proj->_con, RegMask::Empty, (uint)OptoReg::Bad);
 
   case TypeFunc::Parms: {       // Normal returns
     uint ideal_reg = tf()->range()->field_at(TypeFunc::Parms)->ideal_reg();
@@ -700,7 +700,7 @@
     RegMask rm = RegMask(regs.first());
     if( OptoReg::is_valid(regs.second()) )
       rm.Insert( regs.second() );
-    return new (match->C) MachProjNode(this,proj->_con,rm,ideal_reg);
+    return new MachProjNode(this,proj->_con,rm,ideal_reg);
   }
 
   case TypeFunc::ReturnAdr:
@@ -1090,6 +1090,7 @@
 #ifndef PRODUCT
 void SafePointNode::dump_spec(outputStream *st) const {
   st->print(" SafePoint ");
+  _replaced_nodes.dump(st);
 }
 #endif
 
@@ -1288,10 +1289,10 @@
         Node* nproj = catchproj->clone();
         igvn->register_new_node_with_optimizer(nproj);
 
-        Node *frame = new (phase->C) ParmNode( phase->C->start(), TypeFunc::FramePtr );
+        Node *frame = new ParmNode( phase->C->start(), TypeFunc::FramePtr );
         frame = phase->transform(frame);
         // Halt & Catch Fire
-        Node *halt = new (phase->C) HaltNode( nproj, frame );
+        Node *halt = new HaltNode( nproj, frame );
         phase->C->root()->add_req(halt);
         phase->transform(halt);
 
@@ -1333,7 +1334,7 @@
       if (!allow_new_nodes) return NULL;
       // Create a cast which is control dependent on the initialization to
       // propagate the fact that the array length must be positive.
-      length = new (phase->C) CastIINode(length, narrow_length_type);
+      length = new CastIINode(length, narrow_length_type);
       length->set_req(0, initialization()->proj_out(0));
     }
   }
--- a/src/share/vm/opto/callnode.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/callnode.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -30,6 +30,7 @@
 #include "opto/multnode.hpp"
 #include "opto/opcodes.hpp"
 #include "opto/phaseX.hpp"
+#include "opto/replacednodes.hpp"
 #include "opto/type.hpp"
 
 // Portions of code courtesy of Clifford Click
@@ -335,6 +336,7 @@
   OopMap*         _oop_map;   // Array of OopMap info (8-bit char) for GC
   JVMState* const _jvms;      // Pointer to list of JVM State objects
   const TypePtr*  _adr_type;  // What type of memory does this node produce?
+  ReplacedNodes   _replaced_nodes; // During parsing: list of pair of nodes from calls to GraphKit::replace_in_map()
 
   // Many calls take *all* of memory as input,
   // but some produce a limited subset of that memory as output.
@@ -426,6 +428,37 @@
   void               set_next_exception(SafePointNode* n);
   bool                   has_exceptions() const { return next_exception() != NULL; }
 
+  // Helper methods to operate on replaced nodes
+  ReplacedNodes replaced_nodes() const {
+    return _replaced_nodes;
+  }
+
+  void set_replaced_nodes(ReplacedNodes replaced_nodes) {
+    _replaced_nodes = replaced_nodes;
+  }
+
+  void clone_replaced_nodes() {
+    _replaced_nodes.clone();
+  }
+  void record_replaced_node(Node* initial, Node* improved) {
+    _replaced_nodes.record(initial, improved);
+  }
+  void transfer_replaced_nodes_from(SafePointNode* sfpt, uint idx = 0) {
+    _replaced_nodes.transfer_from(sfpt->_replaced_nodes, idx);
+  }
+  void delete_replaced_nodes() {
+    _replaced_nodes.reset();
+  }
+  void apply_replaced_nodes() {
+    _replaced_nodes.apply(this);
+  }
+  void merge_replaced_nodes_with(SafePointNode* sfpt) {
+    _replaced_nodes.merge_with(sfpt->_replaced_nodes);
+  }
+  bool has_replaced_nodes() const {
+    return !_replaced_nodes.is_empty();
+  }
+
   // Standard Node stuff
   virtual int            Opcode() const;
   virtual bool           pinned() const { return true; }
--- a/src/share/vm/opto/castnode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/castnode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -228,11 +228,11 @@
                                 Node* dispX,
                                 bool negate = false) {
   if (negate) {
-    dispX = new (phase->C) SubXNode(phase->MakeConX(0), phase->transform(dispX));
+    dispX = new SubXNode(phase->MakeConX(0), phase->transform(dispX));
   }
-  return new (phase->C) AddPNode(phase->C->top(),
-                                 phase->transform(new (phase->C) CastX2PNode(base)),
-                                 phase->transform(dispX));
+  return new AddPNode(phase->C->top(),
+                      phase->transform(new CastX2PNode(base)),
+                      phase->transform(dispX));
 }
 
 Node *CastX2PNode::Ideal(PhaseGVN *phase, bool can_reshape) {
--- a/src/share/vm/opto/cfgnode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/cfgnode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -662,17 +662,17 @@
                 convf2i->in(1) == bot_in ) {
                 // Matched pattern, including LShiftI; RShiftI, replace with integer compares
                 // max test
-                Node *cmp   = gvn->register_new_node_with_optimizer(new (phase->C) CmpINode( convf2i, min ));
-                Node *boo   = gvn->register_new_node_with_optimizer(new (phase->C) BoolNode( cmp, BoolTest::lt ));
-                IfNode *iff = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C) IfNode( top_if->in(0), boo, PROB_UNLIKELY_MAG(5), top_if->_fcnt ));
-                Node *if_min= gvn->register_new_node_with_optimizer(new (phase->C) IfTrueNode (iff));
-                Node *ifF   = gvn->register_new_node_with_optimizer(new (phase->C) IfFalseNode(iff));
+                Node *cmp   = gvn->register_new_node_with_optimizer(new CmpINode( convf2i, min ));
+                Node *boo   = gvn->register_new_node_with_optimizer(new BoolNode( cmp, BoolTest::lt ));
+                IfNode *iff = (IfNode*)gvn->register_new_node_with_optimizer(new IfNode( top_if->in(0), boo, PROB_UNLIKELY_MAG(5), top_if->_fcnt ));
+                Node *if_min= gvn->register_new_node_with_optimizer(new IfTrueNode (iff));
+                Node *ifF   = gvn->register_new_node_with_optimizer(new IfFalseNode(iff));
                 // min test
-                cmp         = gvn->register_new_node_with_optimizer(new (phase->C) CmpINode( convf2i, max ));
-                boo         = gvn->register_new_node_with_optimizer(new (phase->C) BoolNode( cmp, BoolTest::gt ));
-                iff         = (IfNode*)gvn->register_new_node_with_optimizer(new (phase->C) IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt ));
-                Node *if_max= gvn->register_new_node_with_optimizer(new (phase->C) IfTrueNode (iff));
-                ifF         = gvn->register_new_node_with_optimizer(new (phase->C) IfFalseNode(iff));
+                cmp         = gvn->register_new_node_with_optimizer(new CmpINode( convf2i, max ));
+                boo         = gvn->register_new_node_with_optimizer(new BoolNode( cmp, BoolTest::gt ));
+                iff         = (IfNode*)gvn->register_new_node_with_optimizer(new IfNode( ifF, boo, PROB_UNLIKELY_MAG(5), bot_if->_fcnt ));
+                Node *if_max= gvn->register_new_node_with_optimizer(new IfTrueNode (iff));
+                ifF         = gvn->register_new_node_with_optimizer(new IfFalseNode(iff));
                 // update input edges to region node
                 set_req_X( min_idx, if_min, gvn );
                 set_req_X( max_idx, if_max, gvn );
@@ -731,7 +731,7 @@
 PhiNode* PhiNode::make(Node* r, Node* x, const Type *t, const TypePtr* at) {
   uint preds = r->req();   // Number of predecessor paths
   assert(t != Type::MEMORY || at == flatten_phi_adr_type(at), "flatten at");
-  PhiNode* p = new (Compile::current()) PhiNode(r, t, at);
+  PhiNode* p = new PhiNode(r, t, at);
   for (uint j = 1; j < preds; j++) {
     // Fill in all inputs, except those which the region does not yet have
     if (r->in(j) != NULL)
@@ -749,7 +749,7 @@
   const Type*    t  = x->bottom_type();
   const TypePtr* at = NULL;
   if (t == Type::MEMORY)  at = flatten_phi_adr_type(x->adr_type());
-  return new (Compile::current()) PhiNode(r, t, at);
+  return new PhiNode(r, t, at);
 }
 
 
@@ -1258,9 +1258,9 @@
   } else return NULL;
 
   // Build int->bool conversion
-  Node *n = new (phase->C) Conv2BNode( cmp->in(1) );
+  Node *n = new Conv2BNode( cmp->in(1) );
   if( flipped )
-    n = new (phase->C) XorINode( phase->transform(n), phase->intcon(1) );
+    n = new XorINode( phase->transform(n), phase->intcon(1) );
 
   return n;
 }
@@ -1320,9 +1320,9 @@
   if( q->is_Con() && phase->type(q) != TypeInt::ZERO && y->is_Con() )
     return NULL;
 
-  Node *cmplt = phase->transform( new (phase->C) CmpLTMaskNode(p,q) );
-  Node *j_and   = phase->transform( new (phase->C) AndINode(cmplt,y) );
-  return new (phase->C) AddINode(j_and,x);
+  Node *cmplt = phase->transform( new CmpLTMaskNode(p,q) );
+  Node *j_and   = phase->transform( new AndINode(cmplt,y) );
+  return new AddINode(j_and,x);
 }
 
 //------------------------------is_absolute------------------------------------
@@ -1384,17 +1384,17 @@
     if( sub->Opcode() != Op_SubF ||
         sub->in(2) != x ||
         phase->type(sub->in(1)) != tzero ) return NULL;
-    x = new (phase->C) AbsFNode(x);
+    x = new AbsFNode(x);
     if (flip) {
-      x = new (phase->C) SubFNode(sub->in(1), phase->transform(x));
+      x = new SubFNode(sub->in(1), phase->transform(x));
     }
   } else {
     if( sub->Opcode() != Op_SubD ||
         sub->in(2) != x ||
         phase->type(sub->in(1)) != tzero ) return NULL;
-    x = new (phase->C) AbsDNode(x);
+    x = new AbsDNode(x);
     if (flip) {
-      x = new (phase->C) SubDNode(sub->in(1), phase->transform(x));
+      x = new SubDNode(sub->in(1), phase->transform(x));
     }
   }
 
@@ -1469,7 +1469,7 @@
   // Now start splitting out the flow paths that merge the same value.
   // Split first the RegionNode.
   PhaseIterGVN *igvn = phase->is_IterGVN();
-  RegionNode *newr = new (phase->C) RegionNode(hit+1);
+  RegionNode *newr = new RegionNode(hit+1);
   split_once(igvn, phi, val, r, newr);
 
   // Now split all other Phis than this one
@@ -1781,13 +1781,13 @@
       }
       if (doit) {
         if (base == NULL) {
-          base = new (phase->C) PhiNode(in(0), type, NULL);
+          base = new PhiNode(in(0), type, NULL);
           for (uint i = 1; i < req(); i++) {
             base->init_req(i, in(i)->in(AddPNode::Base));
           }
           phase->is_IterGVN()->register_new_node_with_optimizer(base);
         }
-        return new (phase->C) AddPNode(base, base, y);
+        return new AddPNode(base, base, y);
       }
     }
   }
@@ -1864,7 +1864,7 @@
         // Phi(...MergeMem(m0, m1:AT1, m2:AT2)...) into
         //     MergeMem(Phi(...m0...), Phi:AT1(...m1...), Phi:AT2(...m2...))
         PhaseIterGVN *igvn = phase->is_IterGVN();
-        Node* hook = new (phase->C) Node(1);
+        Node* hook = new Node(1);
         PhiNode* new_base = (PhiNode*) clone();
         // Must eagerly register phis, since they participate in loops.
         if (igvn) {
@@ -1961,7 +1961,7 @@
       } else {
         narrow_t = TypeNarrowKlass::make(this->bottom_type()->is_ptr());
       }
-      PhiNode* new_phi = new (phase->C) PhiNode(r, narrow_t);
+      PhiNode* new_phi = new PhiNode(r, narrow_t);
       uint orig_cnt = req();
       for (uint i=1; i<req(); ++i) {// For all paths in
         Node *ii = in(i);
@@ -1975,9 +1975,9 @@
             new_ii = new_phi;
           } else {
             if (is_decodeN) {
-              new_ii = new (phase->C) EncodePNode(ii, narrow_t);
+              new_ii = new EncodePNode(ii, narrow_t);
             } else {
-              new_ii = new (phase->C) EncodePKlassNode(ii, narrow_t);
+              new_ii = new EncodePKlassNode(ii, narrow_t);
             }
             igvn->register_new_node_with_optimizer(new_ii);
           }
@@ -1986,9 +1986,9 @@
       }
       igvn->register_new_node_with_optimizer(new_phi, this);
       if (is_decodeN) {
-        progress = new (phase->C) DecodeNNode(new_phi, bottom_type());
+        progress = new DecodeNNode(new_phi, bottom_type());
       } else {
-        progress = new (phase->C) DecodeNKlassNode(new_phi, bottom_type());
+        progress = new DecodeNKlassNode(new_phi, bottom_type());
       }
     }
   }
--- a/src/share/vm/opto/chaitin.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/chaitin.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1730,7 +1730,7 @@
 
   // Now we see we need a base-Phi here to merge the bases
   const Type *t = base->bottom_type();
-  base = new (C) PhiNode( derived->in(0), t );
+  base = new PhiNode( derived->in(0), t );
   for( i = 1; i < derived->req(); i++ ) {
     base->init_req(i, find_base_for_derived(derived_base_map, derived->in(i), maxlrg));
     t = t->meet(base->in(i)->bottom_type());
@@ -1800,7 +1800,7 @@
           Block *phi_block = _cfg.get_block_for_node(phi);
           if (_cfg.get_block_for_node(phi_block->pred(2)) == block) {
             const RegMask *mask = C->matcher()->idealreg2spillmask[Op_RegI];
-            Node *spill = new (C) MachSpillCopyNode(MachSpillCopyNode::LoopPhiInput, phi, *mask, *mask);
+            Node *spill = new MachSpillCopyNode(MachSpillCopyNode::LoopPhiInput, phi, *mask, *mask);
             insert_proj( phi_block, 1, spill, maxlrg++ );
             n->set_req(1,spill);
             must_recompute_live = true;
--- a/src/share/vm/opto/coalesce.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/coalesce.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -291,7 +291,7 @@
               _phc.clone_projs(pred, pred->end_idx(), m, copy, _phc._lrg_map);
             } else {
               const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()];
-              copy = new (C) MachSpillCopyNode(MachSpillCopyNode::PhiInput, m, *rm, *rm);
+              copy = new MachSpillCopyNode(MachSpillCopyNode::PhiInput, m, *rm, *rm);
               // Find a good place to insert.  Kinda tricky, use a subroutine
               insert_copy_with_overlap(pred,copy,phi_name,src_name);
             }
@@ -325,7 +325,7 @@
               l += _phc.clone_projs(b, l, m, copy, _phc._lrg_map);
             } else {
               const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()];
-              copy = new (C) MachSpillCopyNode(MachSpillCopyNode::TwoAddress, m, *rm, *rm);
+              copy = new MachSpillCopyNode(MachSpillCopyNode::TwoAddress, m, *rm, *rm);
               // Insert the copy in the basic block, just before us
               b->insert_node(copy, l++);
             }
@@ -372,7 +372,7 @@
                 continue;     // Live out; do not pre-split
               // Split the lrg at this use
               const RegMask *rm = C->matcher()->idealreg2spillmask[inp->ideal_reg()];
-              Node* copy = new (C) MachSpillCopyNode(MachSpillCopyNode::DebugUse, inp, *rm, *rm);
+              Node* copy = new MachSpillCopyNode(MachSpillCopyNode::DebugUse, inp, *rm, *rm);
               // Insert the copy in the use-def chain
               n->set_req(inpidx, copy );
               // Insert the copy in the basic block, just before us
--- a/src/share/vm/opto/compile.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/compile.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -95,7 +95,7 @@
 // Constant table base node singleton.
 MachConstantBaseNode* Compile::mach_constant_base_node() {
   if (_mach_constant_base_node == NULL) {
-    _mach_constant_base_node = new (C) MachConstantBaseNode();
+    _mach_constant_base_node = new MachConstantBaseNode();
     _mach_constant_base_node->add_req(C->root());
   }
   return _mach_constant_base_node;
@@ -392,6 +392,11 @@
   uint next = 0;
   while (next < useful.size()) {
     Node *n = useful.at(next++);
+    if (n->is_SafePoint()) {
+      // We're done with a parsing phase. Replaced nodes are not valid
+      // beyond that point.
+      n->as_SafePoint()->delete_replaced_nodes();
+    }
     // Use raw traversal of out edges since this code removes out edges
     int max = n->outcnt();
     for (int j = 0; j < max; ++j) {
@@ -673,7 +678,6 @@
                   _print_inlining_stream(NULL),
                   _print_inlining_idx(0),
                   _print_inlining_output(NULL),
-                  _preserve_jvm_state(0),
                   _interpreter_frame_size(0) {
   C = this;
 
@@ -748,14 +752,14 @@
       const TypeTuple *domain = StartOSRNode::osr_domain();
       const TypeTuple *range = TypeTuple::make_range(method()->signature());
       init_tf(TypeFunc::make(domain, range));
-      StartNode* s = new (this) StartOSRNode(root(), domain);
+      StartNode* s = new StartOSRNode(root(), domain);
       initial_gvn()->set_type_bottom(s);
       init_start(s);
       cg = CallGenerator::for_osr(method(), entry_bci());
     } else {
       // Normal case.
       init_tf(TypeFunc::make(method()));
-      StartNode* s = new (this) StartNode(root(), tf()->domain());
+      StartNode* s = new StartNode(root(), tf()->domain());
       initial_gvn()->set_type_bottom(s);
       init_start(s);
       if (method()->intrinsic_id() == vmIntrinsics::_Reference_get && UseG1GC) {
@@ -783,7 +787,7 @@
       return;
     }
     JVMState* jvms = build_start_state(start(), tf());
-    if ((jvms = cg->generate(jvms, NULL)) == NULL) {
+    if ((jvms = cg->generate(jvms)) == NULL) {
       record_method_not_compilable("method parse failed");
       return;
     }
@@ -980,7 +984,6 @@
     _print_inlining_stream(NULL),
     _print_inlining_idx(0),
     _print_inlining_output(NULL),
-    _preserve_jvm_state(0),
     _allowed_reasons(0),
     _interpreter_frame_size(0) {
   C = this;
@@ -1061,9 +1064,9 @@
   // Globally visible Nodes
   // First set TOP to NULL to give safe behavior during creation of RootNode
   set_cached_top_node(NULL);
-  set_root(new (this) RootNode());
+  set_root(new RootNode());
   // Now that you have a Root to point to, create the real TOP
-  set_cached_top_node( new (this) ConNode(Type::TOP) );
+  set_cached_top_node( new ConNode(Type::TOP) );
   set_recent_alloc(NULL, NULL);
 
   // Create Debug Information Recorder to record scopes, oopmaps, etc.
@@ -1914,6 +1917,8 @@
     for_igvn()->clear();
     gvn->replace_with(&igvn);
 
+    _late_inlines_pos = _late_inlines.length();
+
     while (_boxing_late_inlines.length() > 0) {
       CallGenerator* cg = _boxing_late_inlines.pop();
       cg->do_late_inline();
@@ -1977,8 +1982,8 @@
     if (live_nodes() > (uint)LiveNodeCountInliningCutoff) {
       if (low_live_nodes < (uint)LiveNodeCountInliningCutoff * 8 / 10) {
         // PhaseIdealLoop is expensive so we only try it once we are
-        // out of loop and we only try it again if the previous helped
-        // got the number of nodes down significantly
+        // out of live nodes and we only try it again if the previous
+        // helped got the number of nodes down significantly
         PhaseIdealLoop ideal_loop( igvn, false, true );
         if (failing())  return;
         low_live_nodes = live_nodes();
@@ -2072,6 +2077,10 @@
     // Inline valueOf() methods now.
     inline_boxing_calls(igvn);
 
+    if (AlwaysIncrementalInline) {
+      inline_incrementally(igvn);
+    }
+
     print_method(PHASE_INCREMENTAL_BOXING_INLINE, 2);
 
     if (failing())  return;
@@ -2757,9 +2766,9 @@
           // Decode a narrow oop to match address
           // [R12 + narrow_oop_reg<<3 + offset]
           if (t->isa_oopptr()) {
-            nn = new (this) DecodeNNode(nn, t);
+            nn = new DecodeNNode(nn, t);
           } else {
-            nn = new (this) DecodeNKlassNode(nn, t);
+            nn = new DecodeNKlassNode(nn, t);
           }
           n->set_req(AddPNode::Base, nn);
           n->set_req(AddPNode::Address, nn);
@@ -2880,7 +2889,7 @@
         }
       }
       if (new_in2 != NULL) {
-        Node* cmpN = new (this) CmpNNode(in1->in(1), new_in2);
+        Node* cmpN = new CmpNNode(in1->in(1), new_in2);
         n->subsume_by(cmpN, this);
         if (in1->outcnt() == 0) {
           in1->disconnect_inputs(NULL, this);
@@ -2979,8 +2988,8 @@
           n->subsume_by(divmod->mod_proj(), this);
         } else {
           // replace a%b with a-((a/b)*b)
-          Node* mult = new (this) MulINode(d, d->in(2));
-          Node* sub  = new (this) SubINode(d->in(1), mult);
+          Node* mult = new MulINode(d, d->in(2));
+          Node* sub  = new SubINode(d->in(1), mult);
           n->subsume_by(sub, this);
         }
       }
@@ -2999,8 +3008,8 @@
           n->subsume_by(divmod->mod_proj(), this);
         } else {
           // replace a%b with a-((a/b)*b)
-          Node* mult = new (this) MulLNode(d, d->in(2));
-          Node* sub  = new (this) SubLNode(d->in(1), mult);
+          Node* mult = new MulLNode(d, d->in(2));
+          Node* sub  = new SubLNode(d->in(1), mult);
           n->subsume_by(sub, this);
         }
       }
@@ -3049,7 +3058,7 @@
         }
       } else {
         if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
-          Node* shift = new (this) AndINode(in2, ConNode::make(this, TypeInt::make(mask)));
+          Node* shift = new AndINode(in2, ConNode::make(this, TypeInt::make(mask)));
           n->set_req(2, shift);
         }
       }
--- a/src/share/vm/opto/compile.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/compile.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -431,9 +431,6 @@
   // Remove the speculative part of types and clean up the graph
   void remove_speculative_types(PhaseIterGVN &igvn);
 
-  // Are we within a PreserveJVMState block?
-  int _preserve_jvm_state;
-
   void* _replay_inline_data; // Pointer to data loaded from file
 
   void print_inlining_init();
@@ -1198,21 +1195,6 @@
 
   // Auxiliary method for randomized fuzzing/stressing
   static bool randomized_select(int count);
-
-  // enter a PreserveJVMState block
-  void inc_preserve_jvm_state() {
-    _preserve_jvm_state++;
-  }
-
-  // exit a PreserveJVMState block
-  void dec_preserve_jvm_state() {
-    _preserve_jvm_state--;
-    assert(_preserve_jvm_state >= 0, "_preserve_jvm_state shouldn't be negative");
-  }
-
-  bool has_preserve_jvm_state() const {
-    return _preserve_jvm_state > 0;
-  }
 };
 
 #endif // SHARE_VM_OPTO_COMPILE_HPP
--- a/src/share/vm/opto/connode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/connode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -45,17 +45,17 @@
 //------------------------------make-------------------------------------------
 ConNode *ConNode::make( Compile* C, const Type *t ) {
   switch( t->basic_type() ) {
-  case T_INT:         return new (C) ConINode( t->is_int() );
-  case T_LONG:        return new (C) ConLNode( t->is_long() );
-  case T_FLOAT:       return new (C) ConFNode( t->is_float_constant() );
-  case T_DOUBLE:      return new (C) ConDNode( t->is_double_constant() );
-  case T_VOID:        return new (C) ConNode ( Type::TOP );
-  case T_OBJECT:      return new (C) ConPNode( t->is_ptr() );
-  case T_ARRAY:       return new (C) ConPNode( t->is_aryptr() );
-  case T_ADDRESS:     return new (C) ConPNode( t->is_ptr() );
-  case T_NARROWOOP:   return new (C) ConNNode( t->is_narrowoop() );
-  case T_NARROWKLASS: return new (C) ConNKlassNode( t->is_narrowklass() );
-  case T_METADATA:    return new (C) ConPNode( t->is_ptr() );
+  case T_INT:         return new ConINode( t->is_int() );
+  case T_LONG:        return new ConLNode( t->is_long() );
+  case T_FLOAT:       return new ConFNode( t->is_float_constant() );
+  case T_DOUBLE:      return new ConDNode( t->is_double_constant() );
+  case T_VOID:        return new ConNode ( Type::TOP );
+  case T_OBJECT:      return new ConPNode( t->is_ptr() );
+  case T_ARRAY:       return new ConPNode( t->is_aryptr() );
+  case T_ADDRESS:     return new ConPNode( t->is_ptr() );
+  case T_NARROWOOP:   return new ConNNode( t->is_narrowoop() );
+  case T_NARROWKLASS: return new ConNKlassNode( t->is_narrowklass() );
+  case T_METADATA:    return new ConPNode( t->is_ptr() );
     // Expected cases:  TypePtr::NULL_PTR, any is_rawptr()
     // Also seen: AnyPtr(TopPTR *+top); from command line:
     //   r -XX:+PrintOpto -XX:CIStart=285 -XX:+CompileTheWorld -XX:CompileTheWorldStartAt=660
--- a/src/share/vm/opto/connode.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/connode.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -58,7 +58,7 @@
 
   // Factory method:
   static ConINode* make( Compile* C, int con ) {
-    return new (C) ConINode( TypeInt::make(con) );
+    return new ConINode( TypeInt::make(con) );
   }
 
 };
@@ -73,9 +73,9 @@
   // Factory methods:
   static ConPNode* make( Compile *C ,address con ) {
     if (con == NULL)
-      return new (C) ConPNode( TypePtr::NULL_PTR ) ;
+      return new ConPNode( TypePtr::NULL_PTR ) ;
     else
-      return new (C) ConPNode( TypeRawPtr::make(con) );
+      return new ConPNode( TypeRawPtr::make(con) );
   }
 };
 
@@ -106,7 +106,7 @@
 
   // Factory method:
   static ConLNode* make( Compile *C ,jlong con ) {
-    return new (C) ConLNode( TypeLong::make(con) );
+    return new ConLNode( TypeLong::make(con) );
   }
 
 };
@@ -120,7 +120,7 @@
 
   // Factory method:
   static ConFNode* make( Compile *C, float con  ) {
-    return new (C) ConFNode( TypeF::make(con) );
+    return new ConFNode( TypeF::make(con) );
   }
 
 };
@@ -134,7 +134,7 @@
 
   // Factory method:
   static ConDNode* make( Compile *C, double con ) {
-    return new (C) ConDNode( TypeD::make(con) );
+    return new ConDNode( TypeD::make(con) );
   }
 
 };
--- a/src/share/vm/opto/convertnode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/convertnode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -374,11 +374,11 @@
       ryhi = -rylo0;
     }
 
-    Node* cx = phase->transform( new (phase->C) ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );
-    Node* cy = phase->transform( new (phase->C) ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );
+    Node* cx = phase->transform( new ConvI2LNode(x, TypeLong::make(rxlo, rxhi, widen)) );
+    Node* cy = phase->transform( new ConvI2LNode(y, TypeLong::make(rylo, ryhi, widen)) );
     switch (op) {
-      case Op_AddI:  return new (phase->C) AddLNode(cx, cy);
-      case Op_SubI:  return new (phase->C) SubLNode(cx, cy);
+      case Op_AddI:  return new AddLNode(cx, cy);
+      case Op_SubI:  return new SubLNode(cx, cy);
       default:       ShouldNotReachHere();
     }
   }
@@ -452,9 +452,9 @@
     assert( x != andl && y != andl, "dead loop in ConvL2INode::Ideal" );
     if (phase->type(x) == Type::TOP)  return NULL;
     if (phase->type(y) == Type::TOP)  return NULL;
-    Node *add1 = phase->transform(new (phase->C) ConvL2INode(x));
-    Node *add2 = phase->transform(new (phase->C) ConvL2INode(y));
-    return new (phase->C) AddINode(add1,add2);
+    Node *add1 = phase->transform(new ConvL2INode(x));
+    Node *add2 = phase->transform(new ConvL2INode(y));
+    return new AddINode(add1,add2);
   }
 
   // Disable optimization: LoadL->ConvL2I ==> LoadI.
--- a/src/share/vm/opto/divnode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/divnode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -106,7 +106,7 @@
     // division by +/- 1
     if (!d_pos) {
       // Just negate the value
-      q = new (phase->C) SubINode(phase->intcon(0), dividend);
+      q = new SubINode(phase->intcon(0), dividend);
     }
   } else if ( is_power_of_2(d) ) {
     // division by +/- a power of 2
@@ -143,18 +143,18 @@
       // (-2+3)>>2 becomes 0, etc.
 
       // Compute 0 or -1, based on sign bit
-      Node *sign = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N - 1)));
+      Node *sign = phase->transform(new RShiftINode(dividend, phase->intcon(N - 1)));
       // Mask sign bit to the low sign bits
-      Node *round = phase->transform(new (phase->C) URShiftINode(sign, phase->intcon(N - l)));
+      Node *round = phase->transform(new URShiftINode(sign, phase->intcon(N - l)));
       // Round up before shifting
-      dividend = phase->transform(new (phase->C) AddINode(dividend, round));
+      dividend = phase->transform(new AddINode(dividend, round));
     }
 
     // Shift for division
-    q = new (phase->C) RShiftINode(dividend, phase->intcon(l));
+    q = new RShiftINode(dividend, phase->intcon(l));
 
     if (!d_pos) {
-      q = new (phase->C) SubINode(phase->intcon(0), phase->transform(q));
+      q = new SubINode(phase->intcon(0), phase->transform(q));
     }
   } else {
     // Attempt the jint constant divide -> multiply transform found in
@@ -166,33 +166,33 @@
     jint shift_const;
     if (magic_int_divide_constants(d, magic_const, shift_const)) {
       Node *magic = phase->longcon(magic_const);
-      Node *dividend_long = phase->transform(new (phase->C) ConvI2LNode(dividend));
+      Node *dividend_long = phase->transform(new ConvI2LNode(dividend));
 
       // Compute the high half of the dividend x magic multiplication
-      Node *mul_hi = phase->transform(new (phase->C) MulLNode(dividend_long, magic));
+      Node *mul_hi = phase->transform(new MulLNode(dividend_long, magic));
 
       if (magic_const < 0) {
-        mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N)));
-        mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi));
+        mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(N)));
+        mul_hi = phase->transform(new ConvL2INode(mul_hi));
 
         // The magic multiplier is too large for a 32 bit constant. We've adjusted
         // it down by 2^32, but have to add 1 dividend back in after the multiplication.
         // This handles the "overflow" case described by Granlund and Montgomery.
-        mul_hi = phase->transform(new (phase->C) AddINode(dividend, mul_hi));
+        mul_hi = phase->transform(new AddINode(dividend, mul_hi));
 
         // Shift over the (adjusted) mulhi
         if (shift_const != 0) {
-          mul_hi = phase->transform(new (phase->C) RShiftINode(mul_hi, phase->intcon(shift_const)));
+          mul_hi = phase->transform(new RShiftINode(mul_hi, phase->intcon(shift_const)));
         }
       } else {
         // No add is required, we can merge the shifts together.
-        mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(N + shift_const)));
-        mul_hi = phase->transform(new (phase->C) ConvL2INode(mul_hi));
+        mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(N + shift_const)));
+        mul_hi = phase->transform(new ConvL2INode(mul_hi));
       }
 
       // Get a 0 or -1 from the sign of the dividend.
       Node *addend0 = mul_hi;
-      Node *addend1 = phase->transform(new (phase->C) RShiftINode(dividend, phase->intcon(N-1)));
+      Node *addend1 = phase->transform(new RShiftINode(dividend, phase->intcon(N-1)));
 
       // If the divisor is negative, swap the order of the input addends;
       // this has the effect of negating the quotient.
@@ -202,7 +202,7 @@
 
       // Adjust the final quotient by subtracting -1 (adding 1)
       // from the mul_hi.
-      q = new (phase->C) SubINode(addend0, addend1);
+      q = new SubINode(addend0, addend1);
     }
   }
 
@@ -261,7 +261,7 @@
   // no need to synthesize it in ideal nodes.
   if (Matcher::has_match_rule(Op_MulHiL)) {
     Node* v = phase->longcon(magic_const);
-    return new (phase->C) MulHiLNode(dividend, v);
+    return new MulHiLNode(dividend, v);
   }
 
   // Taken from Hacker's Delight, Fig. 8-2. Multiply high signed.
@@ -287,11 +287,11 @@
   const int N = 64;
 
   // Dummy node to keep intermediate nodes alive during construction
-  Node* hook = new (phase->C) Node(4);
+  Node* hook = new Node(4);
 
   // u0 = u & 0xFFFFFFFF;  u1 = u >> 32;
-  Node* u0 = phase->transform(new (phase->C) AndLNode(dividend, phase->longcon(0xFFFFFFFF)));
-  Node* u1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N / 2)));
+  Node* u0 = phase->transform(new AndLNode(dividend, phase->longcon(0xFFFFFFFF)));
+  Node* u1 = phase->transform(new RShiftLNode(dividend, phase->intcon(N / 2)));
   hook->init_req(0, u0);
   hook->init_req(1, u1);
 
@@ -300,29 +300,29 @@
   Node* v1 = phase->longcon(magic_const >> (N / 2));
 
   // w0 = u0*v0;
-  Node* w0 = phase->transform(new (phase->C) MulLNode(u0, v0));
+  Node* w0 = phase->transform(new MulLNode(u0, v0));
 
   // t = u1*v0 + (w0 >> 32);
-  Node* u1v0 = phase->transform(new (phase->C) MulLNode(u1, v0));
-  Node* temp = phase->transform(new (phase->C) URShiftLNode(w0, phase->intcon(N / 2)));
-  Node* t    = phase->transform(new (phase->C) AddLNode(u1v0, temp));
+  Node* u1v0 = phase->transform(new MulLNode(u1, v0));
+  Node* temp = phase->transform(new URShiftLNode(w0, phase->intcon(N / 2)));
+  Node* t    = phase->transform(new AddLNode(u1v0, temp));
   hook->init_req(2, t);
 
   // w1 = t & 0xFFFFFFFF;
-  Node* w1 = phase->transform(new (phase->C) AndLNode(t, phase->longcon(0xFFFFFFFF)));
+  Node* w1 = phase->transform(new AndLNode(t, phase->longcon(0xFFFFFFFF)));
   hook->init_req(3, w1);
 
   // w2 = t >> 32;
-  Node* w2 = phase->transform(new (phase->C) RShiftLNode(t, phase->intcon(N / 2)));
+  Node* w2 = phase->transform(new RShiftLNode(t, phase->intcon(N / 2)));
 
   // w1 = u0*v1 + w1;
-  Node* u0v1 = phase->transform(new (phase->C) MulLNode(u0, v1));
-  w1         = phase->transform(new (phase->C) AddLNode(u0v1, w1));
+  Node* u0v1 = phase->transform(new MulLNode(u0, v1));
+  w1         = phase->transform(new AddLNode(u0v1, w1));
 
   // return u1*v1 + w2 + (w1 >> 32);
-  Node* u1v1  = phase->transform(new (phase->C) MulLNode(u1, v1));
-  Node* temp1 = phase->transform(new (phase->C) AddLNode(u1v1, w2));
-  Node* temp2 = phase->transform(new (phase->C) RShiftLNode(w1, phase->intcon(N / 2)));
+  Node* u1v1  = phase->transform(new MulLNode(u1, v1));
+  Node* temp1 = phase->transform(new AddLNode(u1v1, w2));
+  Node* temp2 = phase->transform(new RShiftLNode(w1, phase->intcon(N / 2)));
 
   // Remove the bogus extra edges used to keep things alive
   PhaseIterGVN* igvn = phase->is_IterGVN();
@@ -334,7 +334,7 @@
     }
   }
 
-  return new (phase->C) AddLNode(temp1, temp2);
+  return new AddLNode(temp1, temp2);
 }
 
 
@@ -357,7 +357,7 @@
     // division by +/- 1
     if (!d_pos) {
       // Just negate the value
-      q = new (phase->C) SubLNode(phase->longcon(0), dividend);
+      q = new SubLNode(phase->longcon(0), dividend);
     }
   } else if ( is_power_of_2_long(d) ) {
 
@@ -396,18 +396,18 @@
       // (-2+3)>>2 becomes 0, etc.
 
       // Compute 0 or -1, based on sign bit
-      Node *sign = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N - 1)));
+      Node *sign = phase->transform(new RShiftLNode(dividend, phase->intcon(N - 1)));
       // Mask sign bit to the low sign bits
-      Node *round = phase->transform(new (phase->C) URShiftLNode(sign, phase->intcon(N - l)));
+      Node *round = phase->transform(new URShiftLNode(sign, phase->intcon(N - l)));
       // Round up before shifting
-      dividend = phase->transform(new (phase->C) AddLNode(dividend, round));
+      dividend = phase->transform(new AddLNode(dividend, round));
     }
 
     // Shift for division
-    q = new (phase->C) RShiftLNode(dividend, phase->intcon(l));
+    q = new RShiftLNode(dividend, phase->intcon(l));
 
     if (!d_pos) {
-      q = new (phase->C) SubLNode(phase->longcon(0), phase->transform(q));
+      q = new SubLNode(phase->longcon(0), phase->transform(q));
     }
   } else if ( !Matcher::use_asm_for_ldiv_by_con(d) ) { // Use hardware DIV instruction when
                                                        // it is faster than code generated below.
@@ -427,17 +427,17 @@
         // The magic multiplier is too large for a 64 bit constant. We've adjusted
         // it down by 2^64, but have to add 1 dividend back in after the multiplication.
         // This handles the "overflow" case described by Granlund and Montgomery.
-        mul_hi = phase->transform(new (phase->C) AddLNode(dividend, mul_hi));
+        mul_hi = phase->transform(new AddLNode(dividend, mul_hi));
       }
 
       // Shift over the (adjusted) mulhi
       if (shift_const != 0) {
-        mul_hi = phase->transform(new (phase->C) RShiftLNode(mul_hi, phase->intcon(shift_const)));
+        mul_hi = phase->transform(new RShiftLNode(mul_hi, phase->intcon(shift_const)));
       }
 
       // Get a 0 or -1 from the sign of the dividend.
       Node *addend0 = mul_hi;
-      Node *addend1 = phase->transform(new (phase->C) RShiftLNode(dividend, phase->intcon(N-1)));
+      Node *addend1 = phase->transform(new RShiftLNode(dividend, phase->intcon(N-1)));
 
       // If the divisor is negative, swap the order of the input addends;
       // this has the effect of negating the quotient.
@@ -447,7 +447,7 @@
 
       // Adjust the final quotient by subtracting -1 (adding 1)
       // from the mul_hi.
-      q = new (phase->C) SubLNode(addend0, addend1);
+      q = new SubLNode(addend0, addend1);
     }
   }
 
@@ -737,7 +737,7 @@
   assert( frexp((double)reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
 
   // return multiplication by the reciprocal
-  return (new (phase->C) MulFNode(in(1), phase->makecon(TypeF::make(reciprocal))));
+  return (new MulFNode(in(1), phase->makecon(TypeF::make(reciprocal))));
 }
 
 //=============================================================================
@@ -831,7 +831,7 @@
   assert( frexp(reciprocal, &exp) == 0.5, "reciprocal should be power of 2" );
 
   // return multiplication by the reciprocal
-  return (new (phase->C) MulDNode(in(1), phase->makecon(TypeD::make(reciprocal))));
+  return (new MulDNode(in(1), phase->makecon(TypeD::make(reciprocal))));
 }
 
 //=============================================================================
@@ -858,7 +858,7 @@
   if( !ti->is_con() ) return NULL;
   jint con = ti->get_con();
 
-  Node *hook = new (phase->C) Node(1);
+  Node *hook = new Node(1);
 
   // First, special check for modulo 2^k-1
   if( con >= 0 && con < max_jint && is_power_of_2(con+1) ) {
@@ -878,24 +878,24 @@
       hook->init_req(0, x);       // Add a use to x to prevent him from dying
       // Generate code to reduce X rapidly to nearly 2^k-1.
       for( int i = 0; i < trip_count; i++ ) {
-        Node *xl = phase->transform( new (phase->C) AndINode(x,divisor) );
-        Node *xh = phase->transform( new (phase->C) RShiftINode(x,phase->intcon(k)) ); // Must be signed
-        x = phase->transform( new (phase->C) AddINode(xh,xl) );
+        Node *xl = phase->transform( new AndINode(x,divisor) );
+        Node *xh = phase->transform( new RShiftINode(x,phase->intcon(k)) ); // Must be signed
+        x = phase->transform( new AddINode(xh,xl) );
         hook->set_req(0, x);
       }
 
       // Generate sign-fixup code.  Was original value positive?
       // int hack_res = (i >= 0) ? divisor : 1;
-      Node *cmp1 = phase->transform( new (phase->C) CmpINode( in(1), phase->intcon(0) ) );
-      Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) );
-      Node *cmov1= phase->transform( new (phase->C) CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) );
+      Node *cmp1 = phase->transform( new CmpINode( in(1), phase->intcon(0) ) );
+      Node *bol1 = phase->transform( new BoolNode( cmp1, BoolTest::ge ) );
+      Node *cmov1= phase->transform( new CMoveINode(bol1, phase->intcon(1), divisor, TypeInt::POS) );
       // if( x >= hack_res ) x -= divisor;
-      Node *sub  = phase->transform( new (phase->C) SubINode( x, divisor ) );
-      Node *cmp2 = phase->transform( new (phase->C) CmpINode( x, cmov1 ) );
-      Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) );
+      Node *sub  = phase->transform( new SubINode( x, divisor ) );
+      Node *cmp2 = phase->transform( new CmpINode( x, cmov1 ) );
+      Node *bol2 = phase->transform( new BoolNode( cmp2, BoolTest::ge ) );
       // Convention is to not transform the return value of an Ideal
       // since Ideal is expected to return a modified 'this' or a new node.
-      Node *cmov2= new (phase->C) CMoveINode(bol2, x, sub, TypeInt::INT);
+      Node *cmov2= new CMoveINode(bol2, x, sub, TypeInt::INT);
       // cmov2 is now the mod
 
       // Now remove the bogus extra edges used to keep things alive
@@ -918,7 +918,7 @@
   jint pos_con = (con >= 0) ? con : -con;
 
   // integer Mod 1 is always 0
-  if( pos_con == 1 ) return new (phase->C) ConINode(TypeInt::ZERO);
+  if( pos_con == 1 ) return new ConINode(TypeInt::ZERO);
 
   int log2_con = -1;
 
@@ -931,7 +931,7 @@
 
     // See if this can be masked, if the dividend is non-negative
     if( dti && dti->_lo >= 0 )
-      return ( new (phase->C) AndINode( in(1), phase->intcon( pos_con-1 ) ) );
+      return ( new AndINode( in(1), phase->intcon( pos_con-1 ) ) );
   }
 
   // Save in(1) so that it cannot be changed or deleted
@@ -946,12 +946,12 @@
     Node *mult = NULL;
 
     if( log2_con >= 0 )
-      mult = phase->transform( new (phase->C) LShiftINode( divide, phase->intcon( log2_con ) ) );
+      mult = phase->transform( new LShiftINode( divide, phase->intcon( log2_con ) ) );
     else
-      mult = phase->transform( new (phase->C) MulINode( divide, phase->intcon( pos_con ) ) );
+      mult = phase->transform( new MulINode( divide, phase->intcon( pos_con ) ) );
 
     // Finally, subtract the multiplied divided value from the original
-    result = new (phase->C) SubINode( in(1), mult );
+    result = new SubINode( in(1), mult );
   }
 
   // Now remove the bogus extra edges used to keep things alive
@@ -1029,7 +1029,7 @@
   if( !tl->is_con() ) return NULL;
   jlong con = tl->get_con();
 
-  Node *hook = new (phase->C) Node(1);
+  Node *hook = new Node(1);
 
   // Expand mod
   if( con >= 0 && con < max_jlong && is_power_of_2_long(con+1) ) {
@@ -1051,24 +1051,24 @@
       hook->init_req(0, x);       // Add a use to x to prevent him from dying
       // Generate code to reduce X rapidly to nearly 2^k-1.
       for( int i = 0; i < trip_count; i++ ) {
-        Node *xl = phase->transform( new (phase->C) AndLNode(x,divisor) );
-        Node *xh = phase->transform( new (phase->C) RShiftLNode(x,phase->intcon(k)) ); // Must be signed
-        x = phase->transform( new (phase->C) AddLNode(xh,xl) );
+        Node *xl = phase->transform( new AndLNode(x,divisor) );
+        Node *xh = phase->transform( new RShiftLNode(x,phase->intcon(k)) ); // Must be signed
+        x = phase->transform( new AddLNode(xh,xl) );
         hook->set_req(0, x);    // Add a use to x to prevent him from dying
       }
 
       // Generate sign-fixup code.  Was original value positive?
       // long hack_res = (i >= 0) ? divisor : CONST64(1);
-      Node *cmp1 = phase->transform( new (phase->C) CmpLNode( in(1), phase->longcon(0) ) );
-      Node *bol1 = phase->transform( new (phase->C) BoolNode( cmp1, BoolTest::ge ) );
-      Node *cmov1= phase->transform( new (phase->C) CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
+      Node *cmp1 = phase->transform( new CmpLNode( in(1), phase->longcon(0) ) );
+      Node *bol1 = phase->transform( new BoolNode( cmp1, BoolTest::ge ) );
+      Node *cmov1= phase->transform( new CMoveLNode(bol1, phase->longcon(1), divisor, TypeLong::LONG) );
       // if( x >= hack_res ) x -= divisor;
-      Node *sub  = phase->transform( new (phase->C) SubLNode( x, divisor ) );
-      Node *cmp2 = phase->transform( new (phase->C) CmpLNode( x, cmov1 ) );
-      Node *bol2 = phase->transform( new (phase->C) BoolNode( cmp2, BoolTest::ge ) );
+      Node *sub  = phase->transform( new SubLNode( x, divisor ) );
+      Node *cmp2 = phase->transform( new CmpLNode( x, cmov1 ) );
+      Node *bol2 = phase->transform( new BoolNode( cmp2, BoolTest::ge ) );
       // Convention is to not transform the return value of an Ideal
       // since Ideal is expected to return a modified 'this' or a new node.
-      Node *cmov2= new (phase->C) CMoveLNode(bol2, x, sub, TypeLong::LONG);
+      Node *cmov2= new CMoveLNode(bol2, x, sub, TypeLong::LONG);
       // cmov2 is now the mod
 
       // Now remove the bogus extra edges used to keep things alive
@@ -1091,7 +1091,7 @@
   jlong pos_con = (con >= 0) ? con : -con;
 
   // integer Mod 1 is always 0
-  if( pos_con == 1 ) return new (phase->C) ConLNode(TypeLong::ZERO);
+  if( pos_con == 1 ) return new ConLNode(TypeLong::ZERO);
 
   int log2_con = -1;
 
@@ -1104,7 +1104,7 @@
 
     // See if this can be masked, if the dividend is non-negative
     if( dtl && dtl->_lo >= 0 )
-      return ( new (phase->C) AndLNode( in(1), phase->longcon( pos_con-1 ) ) );
+      return ( new AndLNode( in(1), phase->longcon( pos_con-1 ) ) );
   }
 
   // Save in(1) so that it cannot be changed or deleted
@@ -1119,12 +1119,12 @@
     Node *mult = NULL;
 
     if( log2_con >= 0 )
-      mult = phase->transform( new (phase->C) LShiftLNode( divide, phase->intcon( log2_con ) ) );
+      mult = phase->transform( new LShiftLNode( divide, phase->intcon( log2_con ) ) );
     else
-      mult = phase->transform( new (phase->C) MulLNode( divide, phase->longcon( pos_con ) ) );
+      mult = phase->transform( new MulLNode( divide, phase->longcon( pos_con ) ) );
 
     // Finally, subtract the multiplied divided value from the original
-    result = new (phase->C) SubLNode( in(1), mult );
+    result = new SubLNode( in(1), mult );
   }
 
   // Now remove the bogus extra edges used to keep things alive
@@ -1279,9 +1279,9 @@
   assert(n->Opcode() == Op_DivI || n->Opcode() == Op_ModI,
          "only div or mod input pattern accepted");
 
-  DivModINode* divmod = new (C) DivModINode(n->in(0), n->in(1), n->in(2));
-  Node*        dproj  = new (C) ProjNode(divmod, DivModNode::div_proj_num);
-  Node*        mproj  = new (C) ProjNode(divmod, DivModNode::mod_proj_num);
+  DivModINode* divmod = new DivModINode(n->in(0), n->in(1), n->in(2));
+  Node*        dproj  = new ProjNode(divmod, DivModNode::div_proj_num);
+  Node*        mproj  = new ProjNode(divmod, DivModNode::mod_proj_num);
   return divmod;
 }
 
@@ -1291,9 +1291,9 @@
   assert(n->Opcode() == Op_DivL || n->Opcode() == Op_ModL,
          "only div or mod input pattern accepted");
 
-  DivModLNode* divmod = new (C) DivModLNode(n->in(0), n->in(1), n->in(2));
-  Node*        dproj  = new (C) ProjNode(divmod, DivModNode::div_proj_num);
-  Node*        mproj  = new (C) ProjNode(divmod, DivModNode::mod_proj_num);
+  DivModLNode* divmod = new DivModLNode(n->in(0), n->in(1), n->in(2));
+  Node*        dproj  = new ProjNode(divmod, DivModNode::div_proj_num);
+  Node*        mproj  = new ProjNode(divmod, DivModNode::mod_proj_num);
   return divmod;
 }
 
@@ -1308,7 +1308,7 @@
     assert(proj->_con == mod_proj_num, "must be div or mod projection");
     rm = match->modI_proj_mask();
   }
-  return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg);
+  return new MachProjNode(this, proj->_con, rm, ideal_reg);
 }
 
 
@@ -1323,5 +1323,5 @@
     assert(proj->_con == mod_proj_num, "must be div or mod projection");
     rm = match->modL_proj_mask();
   }
-  return new (match->C)MachProjNode(this, proj->_con, rm, ideal_reg);
+  return new MachProjNode(this, proj->_con, rm, ideal_reg);
 }
--- a/src/share/vm/opto/doCall.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/doCall.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -119,12 +119,12 @@
   if (allow_inline && allow_intrinsics) {
     CallGenerator* cg = find_intrinsic(callee, call_does_dispatch);
     if (cg != NULL) {
-      if (cg->is_predicted()) {
+      if (cg->is_predicated()) {
         // Code without intrinsic but, hopefully, inlined.
         CallGenerator* inline_cg = this->call_generator(callee,
               vtable_index, call_does_dispatch, jvms, allow_inline, prof_factor, speculative_receiver_type, false);
         if (inline_cg != NULL) {
-          cg = CallGenerator::for_predicted_intrinsic(cg, inline_cg);
+          cg = CallGenerator::for_predicated_intrinsic(cg, inline_cg);
         }
       }
 
@@ -525,7 +525,7 @@
   // because exceptions don't return to the call site.)
   profile_call(receiver);
 
-  JVMState* new_jvms = cg->generate(jvms, this);
+  JVMState* new_jvms = cg->generate(jvms);
   if (new_jvms == NULL) {
     // When inlining attempt fails (e.g., too many arguments),
     // it may contaminate the current compile state, making it
@@ -539,7 +539,7 @@
     // intrinsic was expecting to optimize. Should always be possible to
     // get a normal java call that may inline in that case
     cg = C->call_generator(cg->method(), vtable_index, call_does_dispatch, jvms, try_inline, prof_factor(), speculative_receiver_type, /* allow_intrinsics= */ false);
-    new_jvms = cg->generate(jvms, this);
+    new_jvms = cg->generate(jvms);
     if (new_jvms == NULL) {
       guarantee(failing(), "call failed to generate:  calls should work");
       return;
@@ -596,7 +596,7 @@
             const Type*       sig_type = TypeOopPtr::make_from_klass(ctype->as_klass());
             if (arg_type != NULL && !arg_type->higher_equal(sig_type)) {
               Node* retnode = pop();
-              Node* cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(), retnode, sig_type));
+              Node* cast_obj = _gvn.transform(new CheckCastPPNode(control(), retnode, sig_type));
               push(cast_obj);
             }
           }
@@ -689,7 +689,7 @@
   }
 
   int len = bcis->length();
-  CatchNode *cn = new (C) CatchNode(control(), i_o, len+1);
+  CatchNode *cn = new CatchNode(control(), i_o, len+1);
   Node *catch_ = _gvn.transform(cn);
 
   // now branch with the exception state to each of the (potential)
@@ -700,14 +700,14 @@
     // Locals are just copied from before the call.
     // Get control from the CatchNode.
     int handler_bci = bcis->at(i);
-    Node* ctrl = _gvn.transform( new (C) CatchProjNode(catch_, i+1,handler_bci));
+    Node* ctrl = _gvn.transform( new CatchProjNode(catch_, i+1,handler_bci));
     // This handler cannot happen?
     if (ctrl == top())  continue;
     set_control(ctrl);
 
     // Create exception oop
     const TypeInstPtr* extype = extypes->at(i)->is_instptr();
-    Node *ex_oop = _gvn.transform(new (C) CreateExNode(extypes->at(i), ctrl, i_o));
+    Node *ex_oop = _gvn.transform(new CreateExNode(extypes->at(i), ctrl, i_o));
 
     // Handle unloaded exception classes.
     if (saw_unloaded->contains(handler_bci)) {
@@ -746,7 +746,7 @@
 
   // The first CatchProj is for the normal return.
   // (Note:  If this is a call to rethrow_Java, this node goes dead.)
-  set_control(_gvn.transform( new (C) CatchProjNode(catch_, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci)));
+  set_control(_gvn.transform( new CatchProjNode(catch_, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci)));
 }
 
 
@@ -797,7 +797,7 @@
     // I'm loading the class from, I can replace the LoadKlass with the
     // klass constant for the exception oop.
     if( ex_node->is_Phi() ) {
-      ex_klass_node = new (C) PhiNode( ex_node->in(0), TypeKlassPtr::OBJECT );
+      ex_klass_node = new PhiNode( ex_node->in(0), TypeKlassPtr::OBJECT );
       for( uint i = 1; i < ex_node->req(); i++ ) {
         Node* p = basic_plus_adr( ex_node->in(i), ex_node->in(i), oopDesc::klass_offset_in_bytes() );
         Node* k = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p, TypeInstPtr::KLASS, TypeKlassPtr::OBJECT) );
@@ -863,7 +863,7 @@
       PreserveJVMState pjvms(this);
       const TypeInstPtr* tinst = TypeOopPtr::make_from_klass_unique(klass)->cast_to_ptr_type(TypePtr::NotNull)->is_instptr();
       assert(klass->has_subklass() || tinst->klass_is_exact(), "lost exactness");
-      Node* ex_oop = _gvn.transform(new (C) CheckCastPPNode(control(), ex_node, tinst));
+      Node* ex_oop = _gvn.transform(new CheckCastPPNode(control(), ex_node, tinst));
       push_ex_oop(ex_oop);      // Push exception oop for handler
 #ifndef PRODUCT
       if (PrintOpto && WizardMode) {
--- a/src/share/vm/opto/escape.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/escape.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -939,7 +939,13 @@
                   strcmp(call->as_CallLeaf()->_name, "aescrypt_encryptBlock") == 0 ||
                   strcmp(call->as_CallLeaf()->_name, "aescrypt_decryptBlock") == 0 ||
                   strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_encryptAESCrypt") == 0 ||
-                  strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0)
+                  strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_decryptAESCrypt") == 0 ||
+                  strcmp(call->as_CallLeaf()->_name, "sha1_implCompress") == 0 ||
+                  strcmp(call->as_CallLeaf()->_name, "sha1_implCompressMB") == 0 ||
+                  strcmp(call->as_CallLeaf()->_name, "sha256_implCompress") == 0 ||
+                  strcmp(call->as_CallLeaf()->_name, "sha256_implCompressMB") == 0 ||
+                  strcmp(call->as_CallLeaf()->_name, "sha512_implCompress") == 0 ||
+                  strcmp(call->as_CallLeaf()->_name, "sha512_implCompressMB") == 0)
                   ))) {
             call->dump();
             fatal(err_msg_res("EA unexpected CallLeaf %s", call->as_CallLeaf()->_name));
--- a/src/share/vm/opto/generateOptoStub.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/generateOptoStub.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -50,7 +50,7 @@
   const TypeTuple *jrange  = C->tf()->range();
 
   // The procedure start
-  StartNode* start = new (C) StartNode(root(), jdomain);
+  StartNode* start = new StartNode(root(), jdomain);
   _gvn.set_type_bottom(start);
 
   // Make a map, with JVM state
@@ -64,7 +64,7 @@
   jvms->set_scloff(max_map);
   jvms->set_endoff(max_map);
   {
-    SafePointNode *map = new (C) SafePointNode( max_map, jvms );
+    SafePointNode *map = new SafePointNode( max_map, jvms );
     jvms->set_map(map);
     set_jvms(jvms);
     assert(map == this->map(), "kit.map is set");
@@ -73,7 +73,7 @@
   // Make up the parameters
   uint i;
   for( i = 0; i < parm_cnt; i++ )
-    map()->init_req(i, _gvn.transform(new (C) ParmNode(start, i)));
+    map()->init_req(i, _gvn.transform(new ParmNode(start, i)));
   for( ; i<map()->req(); i++ )
     map()->init_req(i, top());      // For nicer debugging
 
@@ -81,7 +81,7 @@
   set_all_memory(map()->memory());
 
   // Get base of thread-local storage area
-  Node* thread = _gvn.transform( new (C) ThreadLocalNode() );
+  Node* thread = _gvn.transform( new ThreadLocalNode() );
 
   const int NoAlias = Compile::AliasIdxBot;
 
@@ -166,8 +166,7 @@
 
   //-----------------------------
   // Make the call node
-  CallRuntimeNode *call = new (C)
-    CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
+  CallRuntimeNode *call = new CallRuntimeNode(c_sig, C_function, name, TypePtr::BOTTOM);
   //-----------------------------
 
   // Fix-up the debug info for the call
@@ -184,7 +183,7 @@
   for (; i < parm_cnt; i++) { // Regular input arguments
     // Convert ints to longs if required.
     if (CCallingConventionRequiresIntsAsLongs && jdomain->field_at(i)->isa_int()) {
-      Node* int_as_long = _gvn.transform(new (C) ConvI2LNode(map()->in(i)));
+      Node* int_as_long = _gvn.transform(new ConvI2LNode(map()->in(i)));
       call->init_req(cnt++, int_as_long); // long
       call->init_req(cnt++, top());       // half
     } else {
@@ -200,23 +199,23 @@
 
   //-----------------------------
   // Now set up the return results
-  set_control( _gvn.transform( new (C) ProjNode(call,TypeFunc::Control)) );
-  set_i_o(     _gvn.transform( new (C) ProjNode(call,TypeFunc::I_O    )) );
+  set_control( _gvn.transform( new ProjNode(call,TypeFunc::Control)) );
+  set_i_o(     _gvn.transform( new ProjNode(call,TypeFunc::I_O    )) );
   set_all_memory_call(call);
   if (range->cnt() > TypeFunc::Parms) {
-    Node* retnode = _gvn.transform( new (C) ProjNode(call,TypeFunc::Parms) );
+    Node* retnode = _gvn.transform( new ProjNode(call,TypeFunc::Parms) );
     // C-land is allowed to return sub-word values.  Convert to integer type.
     assert( retval != Type::TOP, "" );
     if (retval == TypeInt::BOOL) {
-      retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFF)) );
+      retnode = _gvn.transform( new AndINode(retnode, intcon(0xFF)) );
     } else if (retval == TypeInt::CHAR) {
-      retnode = _gvn.transform( new (C) AndINode(retnode, intcon(0xFFFF)) );
+      retnode = _gvn.transform( new AndINode(retnode, intcon(0xFFFF)) );
     } else if (retval == TypeInt::BYTE) {
-      retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(24)) );
-      retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(24)) );
+      retnode = _gvn.transform( new LShiftINode(retnode, intcon(24)) );
+      retnode = _gvn.transform( new RShiftINode(retnode, intcon(24)) );
     } else if (retval == TypeInt::SHORT) {
-      retnode = _gvn.transform( new (C) LShiftINode(retnode, intcon(16)) );
-      retnode = _gvn.transform( new (C) RShiftINode(retnode, intcon(16)) );
+      retnode = _gvn.transform( new LShiftINode(retnode, intcon(16)) );
+      retnode = _gvn.transform( new RShiftINode(retnode, intcon(16)) );
     }
     map()->set_req( TypeFunc::Parms, retnode );
   }
@@ -253,21 +252,21 @@
 
   Node* exit_memory = reset_memory();
 
-  Node* cmp = _gvn.transform( new (C) CmpPNode(pending, null()) );
-  Node* bo  = _gvn.transform( new (C) BoolNode(cmp, BoolTest::ne) );
+  Node* cmp = _gvn.transform( new CmpPNode(pending, null()) );
+  Node* bo  = _gvn.transform( new BoolNode(cmp, BoolTest::ne) );
   IfNode   *iff = create_and_map_if(control(), bo, PROB_MIN, COUNT_UNKNOWN);
 
-  Node* if_null     = _gvn.transform( new (C) IfFalseNode(iff) );
-  Node* if_not_null = _gvn.transform( new (C) IfTrueNode(iff)  );
+  Node* if_null     = _gvn.transform( new IfFalseNode(iff) );
+  Node* if_not_null = _gvn.transform( new IfTrueNode(iff)  );
 
   assert (StubRoutines::forward_exception_entry() != NULL, "must be generated before");
   Node *exc_target = makecon(TypeRawPtr::make( StubRoutines::forward_exception_entry() ));
-  Node *to_exc = new (C) TailCallNode(if_not_null,
-                                      i_o(),
-                                      exit_memory,
-                                      frameptr(),
-                                      returnadr(),
-                                      exc_target, null());
+  Node *to_exc = new TailCallNode(if_not_null,
+                                  i_o(),
+                                  exit_memory,
+                                  frameptr(),
+                                  returnadr(),
+                                  exc_target, null());
   root()->add_req(_gvn.transform(to_exc));  // bind to root to keep live
   C->init_start(start);
 
@@ -277,27 +276,27 @@
   switch( is_fancy_jump ) {
   case 0:                       // Make a return instruction
     // Return to caller, free any space for return address
-    ret = new (C) ReturnNode(TypeFunc::Parms, if_null,
-                             i_o(),
-                             exit_memory,
-                             frameptr(),
-                             returnadr());
+    ret = new ReturnNode(TypeFunc::Parms, if_null,
+                         i_o(),
+                         exit_memory,
+                         frameptr(),
+                         returnadr());
     if (C->tf()->range()->cnt() > TypeFunc::Parms)
       ret->add_req( map()->in(TypeFunc::Parms) );
     break;
   case 1:    // This is a fancy tail-call jump.  Jump to computed address.
     // Jump to new callee; leave old return address alone.
-    ret = new (C) TailCallNode(if_null,
-                               i_o(),
-                               exit_memory,
-                               frameptr(),
-                               returnadr(),
-                               target, map()->in(TypeFunc::Parms));
+    ret = new TailCallNode(if_null,
+                           i_o(),
+                           exit_memory,
+                           frameptr(),
+                           returnadr(),
+                           target, map()->in(TypeFunc::Parms));
     break;
   case 2:                       // Pop return address & jump
     // Throw away old return address; jump to new computed address
     //assert(C_function == CAST_FROM_FN_PTR(address, OptoRuntime::rethrow_C), "fancy_jump==2 only for rethrow");
-    ret = new (C) TailJumpNode(if_null,
+    ret = new TailJumpNode(if_null,
                                i_o(),
                                exit_memory,
                                frameptr(),
--- a/src/share/vm/opto/graphKit.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/graphKit.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -294,7 +294,7 @@
       JVMState* jvms = new (C) JVMState(_method, NULL);
       jvms->set_bci(_bci);
       jvms->set_sp(_sp);
-      jvms->set_map(new (C) SafePointNode(TypeFunc::Parms, jvms));
+      jvms->set_map(new SafePointNode(TypeFunc::Parms, jvms));
       set_jvms(jvms);
       for (uint i = 0; i < map()->req(); i++)  map()->init_req(i, top());
       set_all_memory(top());
@@ -347,7 +347,7 @@
   if (region->in(0) != hidden_merge_mark) {
     // The control input is not (yet) a specially-marked region in phi_map.
     // Make it so, and build some phis.
-    region = new (C) RegionNode(2);
+    region = new RegionNode(2);
     _gvn.set_type(region, Type::CONTROL);
     region->set_req(0, hidden_merge_mark);  // marks an internal ex-state
     region->init_req(1, phi_map->control());
@@ -432,6 +432,7 @@
       }
     }
   }
+  phi_map->merge_replaced_nodes_with(ex_map);
 }
 
 //--------------------------use_exception_state--------------------------------
@@ -496,13 +497,13 @@
     // take the uncommon_trap in the BuildCutout below.
 
     // first must access the should_post_on_exceptions_flag in this thread's JavaThread
-    Node* jthread = _gvn.transform(new (C) ThreadLocalNode());
+    Node* jthread = _gvn.transform(new ThreadLocalNode());
     Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset()));
     Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, MemNode::unordered);
 
     // Test the should_post_on_exceptions_flag vs. 0
-    Node* chk = _gvn.transform( new (C) CmpINode(should_post_flag, intcon(0)) );
-    Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) );
+    Node* chk = _gvn.transform( new CmpINode(should_post_flag, intcon(0)) );
+    Node* tst = _gvn.transform( new BoolNode(chk, BoolTest::eq) );
 
     // Branch to slow_path if should_post_on_exceptions_flag was true
     { BuildCutout unless(this, tst, PROB_MAX);
@@ -645,7 +646,6 @@
   _map    = kit->map();   // preserve the map
   _sp     = kit->sp();
   kit->set_map(clone_map ? kit->clone_map() : NULL);
-  Compile::current()->inc_preserve_jvm_state();
 #ifdef ASSERT
   _bci    = kit->bci();
   Parse* parser = kit->is_Parse();
@@ -663,7 +663,6 @@
 #endif
   kit->set_map(_map);
   kit->set_sp(_sp);
-  Compile::current()->dec_preserve_jvm_state();
 }
 
 
@@ -675,8 +674,8 @@
   SafePointNode* outer_map = _map;   // preserved map is caller's
   SafePointNode* inner_map = kit->map();
   IfNode* iff = kit->create_and_map_if(outer_map->control(), p, prob, cnt);
-  outer_map->set_control(kit->gvn().transform( new (kit->C) IfTrueNode(iff) ));
-  inner_map->set_control(kit->gvn().transform( new (kit->C) IfFalseNode(iff) ));
+  outer_map->set_control(kit->gvn().transform( new IfTrueNode(iff) ));
+  inner_map->set_control(kit->gvn().transform( new IfFalseNode(iff) ));
 }
 BuildCutout::~BuildCutout() {
   GraphKit* kit = _kit;
@@ -1118,7 +1117,7 @@
 Node* GraphKit::basic_plus_adr(Node* base, Node* ptr, Node* offset) {
   // short-circuit a common case
   if (offset == intcon(0))  return ptr;
-  return _gvn.transform( new (C) AddPNode(base, ptr, offset) );
+  return _gvn.transform( new AddPNode(base, ptr, offset) );
 }
 
 Node* GraphKit::ConvI2L(Node* offset) {
@@ -1127,7 +1126,7 @@
   if (offset_con != Type::OffsetBot) {
     return longcon((jlong) offset_con);
   }
-  return _gvn.transform( new (C) ConvI2LNode(offset));
+  return _gvn.transform( new ConvI2LNode(offset));
 }
 
 Node* GraphKit::ConvI2UL(Node* offset) {
@@ -1135,9 +1134,9 @@
   if (offset_con != (juint) Type::OffsetBot) {
     return longcon((julong) offset_con);
   }
-  Node* conv = _gvn.transform( new (C) ConvI2LNode(offset));
+  Node* conv = _gvn.transform( new ConvI2LNode(offset));
   Node* mask = _gvn.transform( ConLNode::make(C, (julong) max_juint) );
-  return _gvn.transform( new (C) AndLNode(conv, mask) );
+  return _gvn.transform( new AndLNode(conv, mask) );
 }
 
 Node* GraphKit::ConvL2I(Node* offset) {
@@ -1146,7 +1145,7 @@
   if (offset_con != (jlong)Type::OffsetBot) {
     return intcon((int) offset_con);
   }
-  return _gvn.transform( new (C) ConvL2INode(offset));
+  return _gvn.transform( new ConvL2INode(offset));
 }
 
 //-------------------------load_object_klass-----------------------------------
@@ -1165,7 +1164,7 @@
   Node *alen;
   if (alloc == NULL) {
     Node *r_adr = basic_plus_adr(array, arrayOopDesc::length_offset_in_bytes());
-    alen = _gvn.transform( new (C) LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
+    alen = _gvn.transform( new LoadRangeNode(0, immutable_memory(), r_adr, TypeInt::POS));
   } else {
     alen = alloc->Ideal_length();
     Node* ccast = alloc->make_ideal_length(_gvn.type(array)->is_oopptr(), &_gvn);
@@ -1199,8 +1198,8 @@
   // Construct NULL check
   Node *chk = NULL;
   switch(type) {
-    case T_LONG   : chk = new (C) CmpLNode(value, _gvn.zerocon(T_LONG)); break;
-    case T_INT    : chk = new (C) CmpINode(value, _gvn.intcon(0)); break;
+    case T_LONG   : chk = new CmpLNode(value, _gvn.zerocon(T_LONG)); break;
+    case T_INT    : chk = new CmpINode(value, _gvn.intcon(0)); break;
     case T_ARRAY  : // fall through
       type = T_OBJECT;  // simplify further tests
     case T_OBJECT : {
@@ -1247,7 +1246,7 @@
           return value;           // Elided null check quickly!
         }
       }
-      chk = new (C) CmpPNode( value, null() );
+      chk = new CmpPNode( value, null() );
       break;
     }
 
@@ -1258,7 +1257,7 @@
   chk = _gvn.transform(chk);
 
   BoolTest::mask btest = assert_null ? BoolTest::eq : BoolTest::ne;
-  BoolNode *btst = new (C) BoolNode( chk, btest);
+  BoolNode *btst = new BoolNode( chk, btest);
   Node   *tst = _gvn.transform( btst );
 
   //-----------
@@ -1325,8 +1324,8 @@
 
   if (null_control != NULL) {
     IfNode* iff = create_and_map_if(control(), tst, ok_prob, COUNT_UNKNOWN);
-    Node* null_true = _gvn.transform( new (C) IfFalseNode(iff));
-    set_control(      _gvn.transform( new (C) IfTrueNode(iff)));
+    Node* null_true = _gvn.transform( new IfFalseNode(iff));
+    set_control(      _gvn.transform( new IfTrueNode(iff)));
     if (null_true == top())
       explicit_null_checks_elided++;
     (*null_control) = null_true;
@@ -1378,7 +1377,7 @@
   // Object is already not-null?
   if( t == t_not_null ) return obj;
 
-  Node *cast = new (C) CastPPNode(obj,t_not_null);
+  Node *cast = new CastPPNode(obj,t_not_null);
   cast->init_req(0, control());
   cast = _gvn.transform( cast );
 
@@ -1403,60 +1402,17 @@
   // on the map.  This includes locals, stack, and monitors
   // of the current (innermost) JVM state.
 
-  if (!ReplaceInParentMaps) {
+  // don't let inconsistent types from profiling escape this
+  // method
+
+  const Type* told = _gvn.type(old);
+  const Type* tnew = _gvn.type(neww);
+
+  if (!tnew->higher_equal(told)) {
     return;
   }
 
-  // PreserveJVMState doesn't do a deep copy so we can't modify
-  // parents
-  if (Compile::current()->has_preserve_jvm_state()) {
-    return;
-  }
-
-  Parse* parser = is_Parse();
-  bool progress = true;
-  Node* ctrl = map()->in(0);
-  // Follow the chain of parsers and see whether the update can be
-  // done in the map of callers. We can do the replace for a caller if
-  // the current control post dominates the control of a caller.
-  while (parser != NULL && parser->caller() != NULL && progress) {
-    progress = false;
-    Node* parent_map = parser->caller()->map();
-    assert(parser->exits().map()->jvms()->depth() == parser->caller()->depth(), "map mismatch");
-
-    Node* parent_ctrl = parent_map->in(0);
-
-    while (parent_ctrl->is_Region()) {
-      Node* n = parent_ctrl->as_Region()->is_copy();
-      if (n == NULL) {
-        break;
-      }
-      parent_ctrl = n;
-    }
-
-    for (;;) {
-      if (ctrl == parent_ctrl) {
-        // update the map of the exits which is the one that will be
-        // used when compilation resume after inlining
-        parser->exits().map()->replace_edge(old, neww);
-        progress = true;
-        break;
-      }
-      if (ctrl->is_Proj() && ctrl->as_Proj()->is_uncommon_trap_if_pattern(Deoptimization::Reason_none)) {
-        ctrl = ctrl->in(0)->in(0);
-      } else if (ctrl->is_Region()) {
-        Node* n = ctrl->as_Region()->is_copy();
-        if (n == NULL) {
-          break;
-        }
-        ctrl = n;
-      } else {
-        break;
-      }
-    }
-
-    parser = parser->parent_parser();
-  }
+  map()->record_replaced_node(old, neww);
 }
 
 
@@ -1486,7 +1442,7 @@
 
 //------------------------------set_all_memory_call----------------------------
 void GraphKit::set_all_memory_call(Node* call, bool separate_io_proj) {
-  Node* newmem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory, separate_io_proj) );
+  Node* newmem = _gvn.transform( new ProjNode(call, TypeFunc::Memory, separate_io_proj) );
   set_all_memory(newmem);
 }
 
@@ -1721,9 +1677,9 @@
   int index_max = max_jint - 1;  // array size is max_jint, index is one less
   if (sizetype != NULL)  index_max = sizetype->_hi - 1;
   const TypeLong* lidxtype = TypeLong::make(CONST64(0), index_max, Type::WidenMax);
-  idx = _gvn.transform( new (C) ConvI2LNode(idx, lidxtype) );
+  idx = _gvn.transform( new ConvI2LNode(idx, lidxtype) );
 #endif
-  Node* scale = _gvn.transform( new (C) LShiftXNode(idx, intcon(shift)) );
+  Node* scale = _gvn.transform( new LShiftXNode(idx, intcon(shift)) );
   return basic_plus_adr(ary, base, scale);
 }
 
@@ -1771,8 +1727,8 @@
 
   // Re-use the current map to produce the result.
 
-  set_control(_gvn.transform(new (C) ProjNode(call, TypeFunc::Control)));
-  set_i_o(    _gvn.transform(new (C) ProjNode(call, TypeFunc::I_O    , separate_io_proj)));
+  set_control(_gvn.transform(new ProjNode(call, TypeFunc::Control)));
+  set_i_o(    _gvn.transform(new ProjNode(call, TypeFunc::I_O    , separate_io_proj)));
   set_all_memory_call(xcall, separate_io_proj);
 
   //return xcall;   // no need, caller already has it
@@ -1786,7 +1742,7 @@
   if (call->method() == NULL ||
       call->method()->return_type()->basic_type() == T_VOID)
         ret = top();
-  else  ret = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+  else  ret = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
 
   // Note:  Since any out-of-line call can produce an exception,
   // we always insert an I_O projection from the call into the result.
@@ -1797,8 +1753,8 @@
     // The caller requested separate projections be used by the fall
     // through and exceptional paths, so replace the projections for
     // the fall through path.
-    set_i_o(_gvn.transform( new (C) ProjNode(call, TypeFunc::I_O) ));
-    set_all_memory(_gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) ));
+    set_i_o(_gvn.transform( new ProjNode(call, TypeFunc::I_O) ));
+    set_all_memory(_gvn.transform( new ProjNode(call, TypeFunc::Memory) ));
   }
   return ret;
 }
@@ -1838,13 +1794,13 @@
                                                       Node* keep_mem,
                                                       const TypePtr* hook_mem) {
   // no i/o
-  set_control(_gvn.transform( new (C) ProjNode(call,TypeFunc::Control) ));
+  set_control(_gvn.transform( new ProjNode(call,TypeFunc::Control) ));
   if (keep_mem) {
     // First clone the existing memory state
     set_all_memory(keep_mem);
     if (hook_mem != NULL) {
       // Make memory for the call
-      Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
+      Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
       // Set the RawPtr memory state only.  This covers all the heap top/GC stuff
       // We also use hook_mem to extract specific effects from arraycopy stubs.
       set_memory(mem, hook_mem);
@@ -1864,12 +1820,16 @@
 
 
 // Replace the call with the current state of the kit.
-void GraphKit::replace_call(CallNode* call, Node* result) {
+void GraphKit::replace_call(CallNode* call, Node* result, bool do_replaced_nodes) {
   JVMState* ejvms = NULL;
   if (has_exceptions()) {
     ejvms = transfer_exceptions_into_jvms();
   }
 
+  ReplacedNodes replaced_nodes = map()->replaced_nodes();
+  ReplacedNodes replaced_nodes_exception;
+  Node* ex_ctl = top();
+
   SafePointNode* final_state = stop();
 
   // Find all the needed outputs of this call
@@ -1886,6 +1846,10 @@
     C->gvn_replace_by(callprojs.fallthrough_catchproj, final_ctl);
   }
   if (callprojs.fallthrough_memproj != NULL) {
+    if (final_mem->is_MergeMem()) {
+      // Parser's exits MergeMem was not transformed but may be optimized
+      final_mem = _gvn.transform(final_mem);
+    }
     C->gvn_replace_by(callprojs.fallthrough_memproj,   final_mem);
   }
   if (callprojs.fallthrough_ioproj != NULL) {
@@ -1917,10 +1881,13 @@
 
     // Load my combined exception state into the kit, with all phis transformed:
     SafePointNode* ex_map = ekit.combine_and_pop_all_exception_states();
+    replaced_nodes_exception = ex_map->replaced_nodes();
 
     Node* ex_oop = ekit.use_exception_state(ex_map);
+
     if (callprojs.catchall_catchproj != NULL) {
       C->gvn_replace_by(callprojs.catchall_catchproj, ekit.control());
+      ex_ctl = ekit.control();
     }
     if (callprojs.catchall_memproj != NULL) {
       C->gvn_replace_by(callprojs.catchall_memproj,   ekit.reset_memory());
@@ -1953,6 +1920,13 @@
       _gvn.transform(wl.pop());
     }
   }
+
+  if (callprojs.fallthrough_catchproj != NULL && !final_ctl->is_top() && do_replaced_nodes) {
+    replaced_nodes.apply(C, final_ctl);
+  }
+  if (!ex_ctl->is_top() && do_replaced_nodes) {
+    replaced_nodes_exception.apply(C, ex_ctl);
+  }
 }
 
 
@@ -1968,7 +1942,7 @@
   int adr_type = Compile::AliasIdxRaw;
   Node* ctrl = control();
   Node* cnt  = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type, MemNode::unordered);
-  Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(1)));
+  Node* incr = _gvn.transform(new AddINode(cnt, _gvn.intcon(1)));
   store_to_memory(ctrl, counter_addr, incr, T_INT, adr_type, MemNode::unordered);
 }
 
@@ -2087,7 +2061,7 @@
   // The debug info is the only real input to this call.
 
   // Halt-and-catch fire here.  The above call should never return!
-  HaltNode* halt = new(C) HaltNode(control(), frameptr());
+  HaltNode* halt = new HaltNode(control(), frameptr());
   _gvn.set_type_bottom(halt);
   root()->add_req(halt);
 
@@ -2169,7 +2143,7 @@
     // the new type. The new type depends on the control: what
     // profiling tells us is only valid from here as far as we can
     // tell.
-    Node* cast = new(C) CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
+    Node* cast = new CheckCastPPNode(control(), n, current_type->remove_speculative()->join_speculative(spec_type));
     cast = _gvn.transform(cast);
     replace_in_map(n, cast);
     n = cast;
@@ -2287,7 +2261,7 @@
 Node* GraphKit::precision_rounding(Node* n) {
   return UseStrictFP && _method->flags().is_strict()
     && UseSSE == 0 && Matcher::strict_fp_requires_explicit_rounding
-    ? _gvn.transform( new (C) RoundFloatNode(0, n) )
+    ? _gvn.transform( new RoundFloatNode(0, n) )
     : n;
 }
 
@@ -2295,7 +2269,7 @@
 Node* GraphKit::dprecision_rounding(Node *n) {
   return UseStrictFP && _method->flags().is_strict()
     && UseSSE <= 1 && Matcher::strict_fp_requires_explicit_rounding
-    ? _gvn.transform( new (C) RoundDoubleNode(0, n) )
+    ? _gvn.transform( new RoundDoubleNode(0, n) )
     : n;
 }
 
@@ -2303,7 +2277,7 @@
 Node* GraphKit::dstore_rounding(Node* n) {
   return Matcher::strict_fp_requires_explicit_rounding
     && UseSSE <= 1
-    ? _gvn.transform( new (C) RoundDoubleNode(0, n) )
+    ? _gvn.transform( new RoundDoubleNode(0, n) )
     : n;
 }
 
@@ -2382,11 +2356,11 @@
   IfNode *opt_iff = _gvn.transform(iff)->as_If();
 
   // Fast path taken; set region slot 2
-  Node *fast_taken = _gvn.transform( new (C) IfFalseNode(opt_iff) );
+  Node *fast_taken = _gvn.transform( new IfFalseNode(opt_iff) );
   region->init_req(2,fast_taken); // Capture fast-control
 
   // Fast path not-taken, i.e. slow path
-  Node *slow_taken = _gvn.transform( new (C) IfTrueNode(opt_iff) );
+  Node *slow_taken = _gvn.transform( new IfTrueNode(opt_iff) );
   return slow_taken;
 }
 
@@ -2410,12 +2384,12 @@
   }
   CallNode* call;
   if (!is_leaf) {
-    call = new(C) CallStaticJavaNode(call_type, call_addr, call_name,
+    call = new CallStaticJavaNode(call_type, call_addr, call_name,
                                            bci(), adr_type);
   } else if (flags & RC_NO_FP) {
-    call = new(C) CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
+    call = new CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
   } else {
-    call = new(C) CallLeafNode(call_type, call_addr, call_name, adr_type);
+    call = new CallLeafNode(call_type, call_addr, call_name, adr_type);
   }
 
   // The following is similar to set_edges_for_java_call,
@@ -2476,7 +2450,7 @@
   }
 
   if (has_io) {
-    set_i_o(_gvn.transform(new (C) ProjNode(call, TypeFunc::I_O)));
+    set_i_o(_gvn.transform(new ProjNode(call, TypeFunc::I_O)));
   }
   return call;
 
@@ -2490,48 +2464,55 @@
     Node* new_slice = mms.memory2();
     if (old_slice != new_slice) {
       PhiNode* phi;
-      if (new_slice->is_Phi() && new_slice->as_Phi()->region() == region) {
-        phi = new_slice->as_Phi();
-        #ifdef ASSERT
-        if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region)
-          old_slice = old_slice->in(new_path);
-        // Caller is responsible for ensuring that any pre-existing
-        // phis are already aware of old memory.
-        int old_path = (new_path > 1) ? 1 : 2;  // choose old_path != new_path
-        assert(phi->in(old_path) == old_slice, "pre-existing phis OK");
-        #endif
-        mms.set_memory(phi);
+      if (old_slice->is_Phi() && old_slice->as_Phi()->region() == region) {
+        if (mms.is_empty()) {
+          // clone base memory Phi's inputs for this memory slice
+          assert(old_slice == mms.base_memory(), "sanity");
+          phi = PhiNode::make(region, NULL, Type::MEMORY, mms.adr_type(C));
+          _gvn.set_type(phi, Type::MEMORY);
+          for (uint i = 1; i < phi->req(); i++) {
+            phi->init_req(i, old_slice->in(i));
+          }
+        } else {
+          phi = old_slice->as_Phi(); // Phi was generated already
+        }
       } else {
         phi = PhiNode::make(region, old_slice, Type::MEMORY, mms.adr_type(C));
         _gvn.set_type(phi, Type::MEMORY);
-        phi->set_req(new_path, new_slice);
-        mms.set_memory(_gvn.transform(phi));  // assume it is complete
       }
+      phi->set_req(new_path, new_slice);
+      mms.set_memory(phi);
     }
   }
 }
 
 //------------------------------make_slow_call_ex------------------------------
 // Make the exception handler hookups for the slow call
-void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj) {
+void GraphKit::make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj, bool deoptimize) {
   if (stopped())  return;
 
   // Make a catch node with just two handlers:  fall-through and catch-all
-  Node* i_o  = _gvn.transform( new (C) ProjNode(call, TypeFunc::I_O, separate_io_proj) );
-  Node* catc = _gvn.transform( new (C) CatchNode(control(), i_o, 2) );
-  Node* norm = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
-  Node* excp = _gvn.transform( new (C) CatchProjNode(catc, CatchProjNode::catch_all_index,    CatchProjNode::no_handler_bci) );
+  Node* i_o  = _gvn.transform( new ProjNode(call, TypeFunc::I_O, separate_io_proj) );
+  Node* catc = _gvn.transform( new CatchNode(control(), i_o, 2) );
+  Node* norm = _gvn.transform( new CatchProjNode(catc, CatchProjNode::fall_through_index, CatchProjNode::no_handler_bci) );
+  Node* excp = _gvn.transform( new CatchProjNode(catc, CatchProjNode::catch_all_index,    CatchProjNode::no_handler_bci) );
 
   { PreserveJVMState pjvms(this);
     set_control(excp);
     set_i_o(i_o);
 
     if (excp != top()) {
-      // Create an exception state also.
-      // Use an exact type if the caller has specified a specific exception.
-      const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
-      Node*       ex_oop  = new (C) CreateExNode(ex_type, control(), i_o);
-      add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
+      if (deoptimize) {
+        // Deoptimize if an exception is caught. Don't construct exception state in this case.
+        uncommon_trap(Deoptimization::Reason_unhandled,
+                      Deoptimization::Action_none);
+      } else {
+        // Create an exception state also.
+        // Use an exact type if the caller has specified a specific exception.
+        const Type* ex_type = TypeOopPtr::make_from_klass_unique(ex_klass)->cast_to_ptr_type(TypePtr::NotNull);
+        Node*       ex_oop  = new CreateExNode(ex_type, control(), i_o);
+        add_exception_state(make_exception_state(_gvn.transform(ex_oop)));
+      }
     }
   }
 
@@ -2580,11 +2561,11 @@
     case SSC_easy_test:
       {
         // Just do a direct pointer compare and be done.
-        Node* cmp = _gvn.transform( new(C) CmpPNode(subklass, superklass) );
-        Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
+        Node* cmp = _gvn.transform( new CmpPNode(subklass, superklass) );
+        Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
         IfNode* iff = create_and_xform_if(control(), bol, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
-        set_control( _gvn.transform( new(C) IfTrueNode (iff) ) );
-        return       _gvn.transform( new(C) IfFalseNode(iff) );
+        set_control( _gvn.transform( new IfTrueNode (iff) ) );
+        return       _gvn.transform( new IfFalseNode(iff) );
       }
     case SSC_full_test:
       break;
@@ -2599,7 +2580,7 @@
 
   // First load the super-klass's check-offset
   Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) );
-  Node *chk_off = _gvn.transform(new (C) LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
+  Node *chk_off = _gvn.transform(new LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(),
                                                    TypeInt::INT, MemNode::unordered));
   int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset());
   bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con);
@@ -2611,7 +2592,7 @@
   // Worst-case type is a little odd: NULL is allowed as a result (usually
   // klass loads can never produce a NULL).
   Node *chk_off_X = ConvI2X(chk_off);
-  Node *p2 = _gvn.transform( new (C) AddPNode(subklass,subklass,chk_off_X) );
+  Node *p2 = _gvn.transform( new AddPNode(subklass,subklass,chk_off_X) );
   // For some types like interfaces the following loadKlass is from a 1-word
   // cache which is mutable so can't use immutable memory.  Other
   // types load from the super-class display table which is immutable.
@@ -2625,11 +2606,11 @@
   // See if we get an immediate positive hit.  Happens roughly 83% of the
   // time.  Test to see if the value loaded just previously from the subklass
   // is exactly the superklass.
-  Node *cmp1 = _gvn.transform( new (C) CmpPNode( superklass, nkls ) );
-  Node *bol1 = _gvn.transform( new (C) BoolNode( cmp1, BoolTest::eq ) );
+  Node *cmp1 = _gvn.transform( new CmpPNode( superklass, nkls ) );
+  Node *bol1 = _gvn.transform( new BoolNode( cmp1, BoolTest::eq ) );
   IfNode *iff1 = create_and_xform_if( control(), bol1, PROB_LIKELY(0.83f), COUNT_UNKNOWN );
-  Node *iftrue1 = _gvn.transform( new (C) IfTrueNode ( iff1 ) );
-  set_control(    _gvn.transform( new (C) IfFalseNode( iff1 ) ) );
+  Node *iftrue1 = _gvn.transform( new IfTrueNode ( iff1 ) );
+  set_control(    _gvn.transform( new IfFalseNode( iff1 ) ) );
 
   // Compile speed common case: Check for being deterministic right now.  If
   // chk_off is a constant and not equal to cacheoff then we are NOT a
@@ -2642,9 +2623,9 @@
   }
 
   // Gather the various success & failures here
-  RegionNode *r_ok_subtype = new (C) RegionNode(4);
+  RegionNode *r_ok_subtype = new RegionNode(4);
   record_for_igvn(r_ok_subtype);
-  RegionNode *r_not_subtype = new (C) RegionNode(3);
+  RegionNode *r_not_subtype = new RegionNode(3);
   record_for_igvn(r_not_subtype);
 
   r_ok_subtype->init_req(1, iftrue1);
@@ -2655,20 +2636,20 @@
   // cache.  If it points to the display (and NOT the cache) and the display
   // missed then it's not a subtype.
   Node *cacheoff = _gvn.intcon(cacheoff_con);
-  Node *cmp2 = _gvn.transform( new (C) CmpINode( chk_off, cacheoff ) );
-  Node *bol2 = _gvn.transform( new (C) BoolNode( cmp2, BoolTest::ne ) );
+  Node *cmp2 = _gvn.transform( new CmpINode( chk_off, cacheoff ) );
+  Node *bol2 = _gvn.transform( new BoolNode( cmp2, BoolTest::ne ) );
   IfNode *iff2 = create_and_xform_if( control(), bol2, PROB_LIKELY(0.63f), COUNT_UNKNOWN );
-  r_not_subtype->init_req(1, _gvn.transform( new (C) IfTrueNode (iff2) ) );
-  set_control(                _gvn.transform( new (C) IfFalseNode(iff2) ) );
+  r_not_subtype->init_req(1, _gvn.transform( new IfTrueNode (iff2) ) );
+  set_control(                _gvn.transform( new IfFalseNode(iff2) ) );
 
   // Check for self.  Very rare to get here, but it is taken 1/3 the time.
   // No performance impact (too rare) but allows sharing of secondary arrays
   // which has some footprint reduction.
-  Node *cmp3 = _gvn.transform( new (C) CmpPNode( subklass, superklass ) );
-  Node *bol3 = _gvn.transform( new (C) BoolNode( cmp3, BoolTest::eq ) );
+  Node *cmp3 = _gvn.transform( new CmpPNode( subklass, superklass ) );
+  Node *bol3 = _gvn.transform( new BoolNode( cmp3, BoolTest::eq ) );
   IfNode *iff3 = create_and_xform_if( control(), bol3, PROB_LIKELY(0.36f), COUNT_UNKNOWN );
-  r_ok_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode ( iff3 ) ) );
-  set_control(               _gvn.transform( new (C) IfFalseNode( iff3 ) ) );
+  r_ok_subtype->init_req(2, _gvn.transform( new IfTrueNode ( iff3 ) ) );
+  set_control(               _gvn.transform( new IfFalseNode( iff3 ) ) );
 
   // -- Roads not taken here: --
   // We could also have chosen to perform the self-check at the beginning
@@ -2692,13 +2673,13 @@
   // The decision to inline or out-of-line this final check is platform
   // dependent, and is found in the AD file definition of PartialSubtypeCheck.
   Node* psc = _gvn.transform(
-    new (C) PartialSubtypeCheckNode(control(), subklass, superklass) );
-
-  Node *cmp4 = _gvn.transform( new (C) CmpPNode( psc, null() ) );
-  Node *bol4 = _gvn.transform( new (C) BoolNode( cmp4, BoolTest::ne ) );
+    new PartialSubtypeCheckNode(control(), subklass, superklass) );
+
+  Node *cmp4 = _gvn.transform( new CmpPNode( psc, null() ) );
+  Node *bol4 = _gvn.transform( new BoolNode( cmp4, BoolTest::ne ) );
   IfNode *iff4 = create_and_xform_if( control(), bol4, PROB_FAIR, COUNT_UNKNOWN );
-  r_not_subtype->init_req(2, _gvn.transform( new (C) IfTrueNode (iff4) ) );
-  r_ok_subtype ->init_req(3, _gvn.transform( new (C) IfFalseNode(iff4) ) );
+  r_not_subtype->init_req(2, _gvn.transform( new IfTrueNode (iff4) ) );
+  r_ok_subtype ->init_req(3, _gvn.transform( new IfFalseNode(iff4) ) );
 
   // Return false path; set default control to true path.
   set_control( _gvn.transform(r_ok_subtype) );
@@ -2762,18 +2743,18 @@
   const TypeKlassPtr* tklass = TypeKlassPtr::make(klass);
   Node* recv_klass = load_object_klass(receiver);
   Node* want_klass = makecon(tklass);
-  Node* cmp = _gvn.transform( new(C) CmpPNode(recv_klass, want_klass) );
-  Node* bol = _gvn.transform( new(C) BoolNode(cmp, BoolTest::eq) );
+  Node* cmp = _gvn.transform( new CmpPNode(recv_klass, want_klass) );
+  Node* bol = _gvn.transform( new BoolNode(cmp, BoolTest::eq) );
   IfNode* iff = create_and_xform_if(control(), bol, prob, COUNT_UNKNOWN);
-  set_control( _gvn.transform( new(C) IfTrueNode (iff) ));
-  Node* fail = _gvn.transform( new(C) IfFalseNode(iff) );
+  set_control( _gvn.transform( new IfTrueNode (iff) ));
+  Node* fail = _gvn.transform( new IfFalseNode(iff) );
 
   const TypeOopPtr* recv_xtype = tklass->as_instance_type();
   assert(recv_xtype->klass_is_exact(), "");
 
   // Subsume downstream occurrences of receiver with a cast to
   // recv_xtype, since now we know what the type will be.
-  Node* cast = new(C) CheckCastPPNode(control(), receiver, recv_xtype);
+  Node* cast = new CheckCastPPNode(control(), receiver, recv_xtype);
   (*casted_receiver) = _gvn.transform(cast);
   // (User must make the replace_in_map call.)
 
@@ -2920,8 +2901,8 @@
 
   // Make the merge point
   enum { _obj_path = 1, _fail_path, _null_path, PATH_LIMIT };
-  RegionNode* region = new(C) RegionNode(PATH_LIMIT);
-  Node*       phi    = new(C) PhiNode(region, TypeInt::BOOL);
+  RegionNode* region = new RegionNode(PATH_LIMIT);
+  Node*       phi    = new PhiNode(region, TypeInt::BOOL);
   C->set_has_split_ifs(true); // Has chance for split-if optimization
 
   ciProfileData* data = NULL;
@@ -3052,8 +3033,8 @@
 
   // Make the merge point
   enum { _obj_path = 1, _null_path, PATH_LIMIT };
-  RegionNode* region = new (C) RegionNode(PATH_LIMIT);
-  Node*       phi    = new (C) PhiNode(region, toop);
+  RegionNode* region = new RegionNode(PATH_LIMIT);
+  Node*       phi    = new PhiNode(region, toop);
   C->set_has_split_ifs(true); // Has chance for split-if optimization
 
   // Use null-cast information if it is available
@@ -3114,8 +3095,7 @@
     Node* not_subtype_ctrl = gen_subtype_check( obj_klass, superklass );
 
     // Plug in success path into the merge
-    cast_obj = _gvn.transform(new (C) CheckCastPPNode(control(),
-                                                         not_null_obj, toop));
+    cast_obj = _gvn.transform(new CheckCastPPNode(control(), not_null_obj, toop));
     // Failure path ends in uncommon trap (or may be dead - failure impossible)
     if (failure_control == NULL) {
       if (not_subtype_ctrl != top()) { // If failure is possible
@@ -3168,7 +3148,7 @@
   mb->init_req(TypeFunc::Control, control());
   mb->init_req(TypeFunc::Memory,  reset_memory());
   Node* membar = _gvn.transform(mb);
-  set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
+  set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
   set_all_memory_call(membar);
   return membar;
 }
@@ -3197,11 +3177,11 @@
     mb->set_req(TypeFunc::Memory, memory(alias_idx));
   }
   Node* membar = _gvn.transform(mb);
-  set_control(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Control)));
+  set_control(_gvn.transform(new ProjNode(membar, TypeFunc::Control)));
   if (alias_idx == Compile::AliasIdxBot) {
-    merged_memory()->set_base_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)));
+    merged_memory()->set_base_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)));
   } else {
-    set_memory(_gvn.transform(new (C) ProjNode(membar, TypeFunc::Memory)),alias_idx);
+    set_memory(_gvn.transform(new ProjNode(membar, TypeFunc::Memory)),alias_idx);
   }
   return membar;
 }
@@ -3221,10 +3201,10 @@
   assert(dead_locals_are_killed(), "should kill locals before sync. point");
 
   // Box the stack location
-  Node* box = _gvn.transform(new (C) BoxLockNode(next_monitor()));
+  Node* box = _gvn.transform(new BoxLockNode(next_monitor()));
   Node* mem = reset_memory();
 
-  FastLockNode * flock = _gvn.transform(new (C) FastLockNode(0, obj, box) )->as_FastLock();
+  FastLockNode * flock = _gvn.transform(new FastLockNode(0, obj, box) )->as_FastLock();
   if (UseBiasedLocking && PrintPreciseBiasedLockingStatistics) {
     // Create the counters for this fast lock.
     flock->create_lock_counter(sync_jvms()); // sync_jvms used to get current bci
@@ -3238,7 +3218,7 @@
   map()->push_monitor( flock );
 
   const TypeFunc *tf = LockNode::lock_type();
-  LockNode *lock = new (C) LockNode(C, tf);
+  LockNode *lock = new LockNode(C, tf);
 
   lock->init_req( TypeFunc::Control, control() );
   lock->init_req( TypeFunc::Memory , mem );
@@ -3292,7 +3272,7 @@
   insert_mem_bar(Op_MemBarReleaseLock);
 
   const TypeFunc *tf = OptoRuntime::complete_monitor_exit_Type();
-  UnlockNode *unlock = new (C) UnlockNode(C, tf);
+  UnlockNode *unlock = new UnlockNode(C, tf);
   uint raw_idx = Compile::AliasIdxRaw;
   unlock->init_req( TypeFunc::Control, control() );
   unlock->init_req( TypeFunc::Memory , memory(raw_idx) );
@@ -3353,24 +3333,25 @@
 
 //---------------------------set_output_for_allocation-------------------------
 Node* GraphKit::set_output_for_allocation(AllocateNode* alloc,
-                                          const TypeOopPtr* oop_type) {
+                                          const TypeOopPtr* oop_type,
+                                          bool deoptimize_on_exception) {
   int rawidx = Compile::AliasIdxRaw;
   alloc->set_req( TypeFunc::FramePtr, frameptr() );
   add_safepoint_edges(alloc);
   Node* allocx = _gvn.transform(alloc);
-  set_control( _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Control) ) );
+  set_control( _gvn.transform(new ProjNode(allocx, TypeFunc::Control) ) );
   // create memory projection for i_o
-  set_memory ( _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
-  make_slow_call_ex(allocx, env()->Throwable_klass(), true);
+  set_memory ( _gvn.transform( new ProjNode(allocx, TypeFunc::Memory, true) ), rawidx );
+  make_slow_call_ex(allocx, env()->Throwable_klass(), true, deoptimize_on_exception);
 
   // create a memory projection as for the normal control path
-  Node* malloc = _gvn.transform(new (C) ProjNode(allocx, TypeFunc::Memory));
+  Node* malloc = _gvn.transform(new ProjNode(allocx, TypeFunc::Memory));
   set_memory(malloc, rawidx);
 
   // a normal slow-call doesn't change i_o, but an allocation does
   // we create a separate i_o projection for the normal control path
-  set_i_o(_gvn.transform( new (C) ProjNode(allocx, TypeFunc::I_O, false) ) );
-  Node* rawoop = _gvn.transform( new (C) ProjNode(allocx, TypeFunc::Parms) );
+  set_i_o(_gvn.transform( new ProjNode(allocx, TypeFunc::I_O, false) ) );
+  Node* rawoop = _gvn.transform( new ProjNode(allocx, TypeFunc::Parms) );
 
   // put in an initialization barrier
   InitializeNode* init = insert_mem_bar_volatile(Op_Initialize, rawidx,
@@ -3406,7 +3387,7 @@
   }
 
   // Cast raw oop to the real thing...
-  Node* javaoop = new (C) CheckCastPPNode(control(), rawoop, oop_type);
+  Node* javaoop = new CheckCastPPNode(control(), rawoop, oop_type);
   javaoop = _gvn.transform(javaoop);
   C->set_recent_alloc(control(), javaoop);
   assert(just_allocated_object(control()) == javaoop, "just allocated");
@@ -3439,9 +3420,11 @@
 // The optional arguments are for specialized use by intrinsics:
 //  - If 'extra_slow_test' if not null is an extra condition for the slow-path.
 //  - If 'return_size_val', report the the total object size to the caller.
+//  - deoptimize_on_exception controls how Java exceptions are handled (rethrow vs deoptimize)
 Node* GraphKit::new_instance(Node* klass_node,
                              Node* extra_slow_test,
-                             Node* *return_size_val) {
+                             Node* *return_size_val,
+                             bool deoptimize_on_exception) {
   // Compute size in doublewords
   // The size is always an integral number of doublewords, represented
   // as a positive bytewise size stored in the klass's layout_helper.
@@ -3465,9 +3448,9 @@
     // (It may be stress-tested by specifying StressReflectiveCode.)
     // Basically, we want to get into the VM is there's an illegal argument.
     Node* bit = intcon(Klass::_lh_instance_slow_path_bit);
-    initial_slow_test = _gvn.transform( new (C) AndINode(layout_val, bit) );
+    initial_slow_test = _gvn.transform( new AndINode(layout_val, bit) );
     if (extra_slow_test != intcon(0)) {
-      initial_slow_test = _gvn.transform( new (C) OrINode(initial_slow_test, extra_slow_test) );
+      initial_slow_test = _gvn.transform( new OrINode(initial_slow_test, extra_slow_test) );
     }
     // (Macro-expander will further convert this to a Bool, if necessary.)
   }
@@ -3484,7 +3467,7 @@
     // Clear the low bits to extract layout_helper_size_in_bytes:
     assert((int)Klass::_lh_instance_slow_path_bit < BytesPerLong, "clear bit");
     Node* mask = MakeConX(~ (intptr_t)right_n_bits(LogBytesPerLong));
-    size = _gvn.transform( new (C) AndXNode(size, mask) );
+    size = _gvn.transform( new AndXNode(size, mask) );
   }
   if (return_size_val != NULL) {
     (*return_size_val) = size;
@@ -3504,13 +3487,12 @@
   Node *mem = reset_memory();
   set_all_memory(mem); // Create new memory state
 
-  AllocateNode* alloc
-    = new (C) AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
-                           control(), mem, i_o(),
-                           size, klass_node,
-                           initial_slow_test);
-
-  return set_output_for_allocation(alloc, oop_type);
+  AllocateNode* alloc = new AllocateNode(C, AllocateNode::alloc_type(Type::TOP),
+                                         control(), mem, i_o(),
+                                         size, klass_node,
+                                         initial_slow_test);
+
+  return set_output_for_allocation(alloc, oop_type, deoptimize_on_exception);
 }
 
 //-------------------------------new_array-------------------------------------
@@ -3520,7 +3502,8 @@
 Node* GraphKit::new_array(Node* klass_node,     // array klass (maybe variable)
                           Node* length,         // number of array elements
                           int   nargs,          // number of arguments to push back for uncommon trap
-                          Node* *return_size_val) {
+                          Node* *return_size_val,
+                          bool deoptimize_on_exception) {
   jint  layout_con = Klass::_lh_neutral_value;
   Node* layout_val = get_layout_helper(klass_node, layout_con);
   int   layout_is_con = (layout_val == NULL);
@@ -3531,8 +3514,8 @@
     // Optimistically assume that it is a subtype of Object[],
     // so that we can fold up all the address arithmetic.
     layout_con = Klass::array_layout_helper(T_OBJECT);
-    Node* cmp_lh = _gvn.transform( new(C) CmpINode(layout_val, intcon(layout_con)) );
-    Node* bol_lh = _gvn.transform( new(C) BoolNode(cmp_lh, BoolTest::eq) );
+    Node* cmp_lh = _gvn.transform( new CmpINode(layout_val, intcon(layout_con)) );
+    Node* bol_lh = _gvn.transform( new BoolNode(cmp_lh, BoolTest::eq) );
     { BuildCutout unless(this, bol_lh, PROB_MAX);
       inc_sp(nargs);
       uncommon_trap(Deoptimization::Reason_class_check,
@@ -3556,8 +3539,8 @@
     fast_size_limit <<= (LogBytesPerLong - log2_esize);
   }
 
-  Node* initial_slow_cmp  = _gvn.transform( new (C) CmpUNode( length, intcon( fast_size_limit ) ) );
-  Node* initial_slow_test = _gvn.transform( new (C) BoolNode( initial_slow_cmp, BoolTest::gt ) );
+  Node* initial_slow_cmp  = _gvn.transform( new CmpUNode( length, intcon( fast_size_limit ) ) );
+  Node* initial_slow_test = _gvn.transform( new BoolNode( initial_slow_cmp, BoolTest::gt ) );
   if (initial_slow_test->is_Bool()) {
     // Hide it behind a CMoveI, or else PhaseIdealLoop::split_up will get sick.
     initial_slow_test = initial_slow_test->as_Bool()->as_int_value(&_gvn);
@@ -3585,10 +3568,10 @@
   } else {
     Node* hss   = intcon(Klass::_lh_header_size_shift);
     Node* hsm   = intcon(Klass::_lh_header_size_mask);
-    Node* hsize = _gvn.transform( new(C) URShiftINode(layout_val, hss) );
-    hsize       = _gvn.transform( new(C) AndINode(hsize, hsm) );
+    Node* hsize = _gvn.transform( new URShiftINode(layout_val, hss) );
+    hsize       = _gvn.transform( new AndINode(hsize, hsm) );
     Node* mask  = intcon(round_mask);
-    header_size = _gvn.transform( new(C) AddINode(hsize, mask) );
+    header_size = _gvn.transform( new AddINode(hsize, mask) );
   }
 
   Node* elem_shift = NULL;
@@ -3613,7 +3596,7 @@
       jlong size_max = arrayOopDesc::max_array_length(T_BYTE);
       if (size_max > tllen->_hi)  size_max = tllen->_hi;
       const TypeLong* tlcon = TypeLong::make(CONST64(0), size_max, Type::WidenMin);
-      lengthx = _gvn.transform( new (C) ConvI2LNode(length, tlcon));
+      lengthx = _gvn.transform( new ConvI2LNode(length, tlcon));
     }
   }
 #endif
@@ -3624,11 +3607,11 @@
   // after a successful allocation.
   Node* abody = lengthx;
   if (elem_shift != NULL)
-    abody     = _gvn.transform( new(C) LShiftXNode(lengthx, elem_shift) );
-  Node* size  = _gvn.transform( new(C) AddXNode(headerx, abody) );
+    abody     = _gvn.transform( new LShiftXNode(lengthx, elem_shift) );
+  Node* size  = _gvn.transform( new AddXNode(headerx, abody) );
   if (round_mask != 0) {
     Node* mask = MakeConX(~round_mask);
-    size       = _gvn.transform( new(C) AndXNode(size, mask) );
+    size       = _gvn.transform( new AndXNode(size, mask) );
   }
   // else if round_mask == 0, the size computation is self-rounding
 
@@ -3646,11 +3629,11 @@
 
   // Create the AllocateArrayNode and its result projections
   AllocateArrayNode* alloc
-    = new (C) AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
-                                control(), mem, i_o(),
-                                size, klass_node,
-                                initial_slow_test,
-                                length);
+    = new AllocateArrayNode(C, AllocateArrayNode::alloc_type(TypeInt::INT),
+                            control(), mem, i_o(),
+                            size, klass_node,
+                            initial_slow_test,
+                            length);
 
   // Cast to correct type.  Note that the klass_node may be constant or not,
   // and in the latter case the actual array type will be inexact also.
@@ -3663,7 +3646,7 @@
     ary_type = ary_type->is_aryptr()->cast_to_size(length_type);
   }
 
-  Node* javaoop = set_output_for_allocation(alloc, ary_type);
+  Node* javaoop = set_output_for_allocation(alloc, ary_type, deoptimize_on_exception);
 
   // Cast length on remaining path to be as narrow as possible
   if (map()->find_edge(length) >= 0) {
@@ -3760,10 +3743,10 @@
   }
 
   Node *cont    = _gvn.intcon(1);
-  Node* opq     = _gvn.transform(new (C) Opaque1Node(C, cont));
-  Node *bol     = _gvn.transform(new (C) Conv2BNode(opq));
+  Node* opq     = _gvn.transform(new Opaque1Node(C, cont));
+  Node *bol     = _gvn.transform(new Conv2BNode(opq));
   IfNode* iff   = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
-  Node* iffalse = _gvn.transform(new (C) IfFalseNode(iff));
+  Node* iffalse = _gvn.transform(new IfFalseNode(iff));
   C->add_predicate_opaq(opq);
   {
     PreserveJVMState pjvms(this);
@@ -3771,7 +3754,7 @@
     inc_sp(nargs);
     uncommon_trap(reason, Deoptimization::Action_maybe_recompile);
   }
-  Node* iftrue = _gvn.transform(new (C) IfTrueNode(iff));
+  Node* iftrue = _gvn.transform(new IfTrueNode(iff));
   set_control(iftrue);
 }
 
@@ -3963,7 +3946,7 @@
       __ if_then(index, BoolTest::ne, zeroX, likely); {
 
         // decrement the index
-        Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
+        Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
 
         // Now get the buffer location we will log the previous value into and store it
         Node *log_addr = __ AddP(no_base, buffer, next_index);
@@ -4006,7 +3989,7 @@
   //  Now do the queue work
   __ if_then(index, BoolTest::ne, zeroX); {
 
-    Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t))));
+    Node* next_index = _gvn.transform(new SubXNode(index, __ ConX(sizeof(intptr_t))));
     Node* log_addr = __ AddP(no_base, buffer, next_index);
 
     // Order, see storeCM.
@@ -4213,5 +4196,5 @@
 Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) {
   // Reify the property as a CastPP node in Ideal graph to comply with monotonicity
   // assumption of CCP analysis.
-  return _gvn.transform(new(C) CastPPNode(ary, ary_type->cast_to_stable(true)));
+  return _gvn.transform(new CastPPNode(ary, ary_type->cast_to_stable(true)));
 }
--- a/src/share/vm/opto/graphKit.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/graphKit.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -309,31 +309,31 @@
 
 
   // Some convenient shortcuts for common nodes
-  Node* IfTrue(IfNode* iff)                   { return _gvn.transform(new (C) IfTrueNode(iff));      }
-  Node* IfFalse(IfNode* iff)                  { return _gvn.transform(new (C) IfFalseNode(iff));     }
+  Node* IfTrue(IfNode* iff)                   { return _gvn.transform(new IfTrueNode(iff));      }
+  Node* IfFalse(IfNode* iff)                  { return _gvn.transform(new IfFalseNode(iff));     }
 
-  Node* AddI(Node* l, Node* r)                { return _gvn.transform(new (C) AddINode(l, r));       }
-  Node* SubI(Node* l, Node* r)                { return _gvn.transform(new (C) SubINode(l, r));       }
-  Node* MulI(Node* l, Node* r)                { return _gvn.transform(new (C) MulINode(l, r));       }
-  Node* DivI(Node* ctl, Node* l, Node* r)     { return _gvn.transform(new (C) DivINode(ctl, l, r));  }
+  Node* AddI(Node* l, Node* r)                { return _gvn.transform(new AddINode(l, r));       }
+  Node* SubI(Node* l, Node* r)                { return _gvn.transform(new SubINode(l, r));       }
+  Node* MulI(Node* l, Node* r)                { return _gvn.transform(new MulINode(l, r));       }
+  Node* DivI(Node* ctl, Node* l, Node* r)     { return _gvn.transform(new DivINode(ctl, l, r));  }
 
-  Node* AndI(Node* l, Node* r)                { return _gvn.transform(new (C) AndINode(l, r));       }
-  Node* OrI(Node* l, Node* r)                 { return _gvn.transform(new (C) OrINode(l, r));        }
-  Node* XorI(Node* l, Node* r)                { return _gvn.transform(new (C) XorINode(l, r));       }
+  Node* AndI(Node* l, Node* r)                { return _gvn.transform(new AndINode(l, r));       }
+  Node* OrI(Node* l, Node* r)                 { return _gvn.transform(new OrINode(l, r));        }
+  Node* XorI(Node* l, Node* r)                { return _gvn.transform(new XorINode(l, r));       }
 
-  Node* MaxI(Node* l, Node* r)                { return _gvn.transform(new (C) MaxINode(l, r));       }
-  Node* MinI(Node* l, Node* r)                { return _gvn.transform(new (C) MinINode(l, r));       }
+  Node* MaxI(Node* l, Node* r)                { return _gvn.transform(new MaxINode(l, r));       }
+  Node* MinI(Node* l, Node* r)                { return _gvn.transform(new MinINode(l, r));       }
 
-  Node* LShiftI(Node* l, Node* r)             { return _gvn.transform(new (C) LShiftINode(l, r));    }
-  Node* RShiftI(Node* l, Node* r)             { return _gvn.transform(new (C) RShiftINode(l, r));    }
-  Node* URShiftI(Node* l, Node* r)            { return _gvn.transform(new (C) URShiftINode(l, r));   }
+  Node* LShiftI(Node* l, Node* r)             { return _gvn.transform(new LShiftINode(l, r));    }
+  Node* RShiftI(Node* l, Node* r)             { return _gvn.transform(new RShiftINode(l, r));    }
+  Node* URShiftI(Node* l, Node* r)            { return _gvn.transform(new URShiftINode(l, r));   }
 
-  Node* CmpI(Node* l, Node* r)                { return _gvn.transform(new (C) CmpINode(l, r));       }
-  Node* CmpL(Node* l, Node* r)                { return _gvn.transform(new (C) CmpLNode(l, r));       }
-  Node* CmpP(Node* l, Node* r)                { return _gvn.transform(new (C) CmpPNode(l, r));       }
-  Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new (C) BoolNode(cmp, relop)); }
+  Node* CmpI(Node* l, Node* r)                { return _gvn.transform(new CmpINode(l, r));       }
+  Node* CmpL(Node* l, Node* r)                { return _gvn.transform(new CmpLNode(l, r));       }
+  Node* CmpP(Node* l, Node* r)                { return _gvn.transform(new CmpPNode(l, r));       }
+  Node* Bool(Node* cmp, BoolTest::mask relop) { return _gvn.transform(new BoolNode(cmp, relop)); }
 
-  Node* AddP(Node* b, Node* a, Node* o)       { return _gvn.transform(new (C) AddPNode(b, a, o));    }
+  Node* AddP(Node* b, Node* a, Node* o)       { return _gvn.transform(new AddPNode(b, a, o));    }
 
   // Convert between int and long, and size_t.
   // (See macros ConvI2X, etc., in type.hpp for ConvI2X, etc.)
@@ -690,7 +690,7 @@
   // Replace the call with the current state of the kit.  Requires
   // that the call was generated with separate io_projs so that
   // exceptional control flow can be handled properly.
-  void replace_call(CallNode* call, Node* result);
+  void replace_call(CallNode* call, Node* result, bool do_replaced_nodes = false);
 
   // helper functions for statistics
   void increment_counter(address counter_addr);   // increment a debug counter
@@ -807,7 +807,7 @@
 
   // merge in all memory slices from new_mem, along the given path
   void merge_memory(Node* new_mem, Node* region, int new_path);
-  void make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj);
+  void make_slow_call_ex(Node* call, ciInstanceKlass* ex_klass, bool separate_io_proj, bool deoptimize = false);
 
   // Helper functions to build synchronizations
   int next_monitor();
@@ -849,13 +849,16 @@
 
   // implementation of object creation
   Node* set_output_for_allocation(AllocateNode* alloc,
-                                  const TypeOopPtr* oop_type);
+                                  const TypeOopPtr* oop_type,
+                                  bool deoptimize_on_exception=false);
   Node* get_layout_helper(Node* klass_node, jint& constant_value);
   Node* new_instance(Node* klass_node,
                      Node* slow_test = NULL,
-                     Node* *return_size_val = NULL);
+                     Node* *return_size_val = NULL,
+                     bool deoptimize_on_exception = false);
   Node* new_array(Node* klass_node, Node* count_val, int nargs,
-                  Node* *return_size_val = NULL);
+                  Node* *return_size_val = NULL,
+                  bool deoptimize_on_exception = false);
 
   // java.lang.String helpers
   Node* load_String_offset(Node* ctrl, Node* str);
@@ -867,7 +870,7 @@
 
   // Handy for making control flow
   IfNode* create_and_map_if(Node* ctrl, Node* tst, float prob, float cnt) {
-    IfNode* iff = new (C) IfNode(ctrl, tst, prob, cnt);// New IfNode's
+    IfNode* iff = new IfNode(ctrl, tst, prob, cnt);// New IfNode's
     _gvn.set_type(iff, iff->Value(&_gvn)); // Value may be known at parse-time
     // Place 'if' on worklist if it will be in graph
     if (!tst->is_Con())  record_for_igvn(iff);     // Range-check and Null-check removal is later
@@ -875,7 +878,7 @@
   }
 
   IfNode* create_and_xform_if(Node* ctrl, Node* tst, float prob, float cnt) {
-    IfNode* iff = new (C) IfNode(ctrl, tst, prob, cnt);// New IfNode's
+    IfNode* iff = new IfNode(ctrl, tst, prob, cnt);// New IfNode's
     _gvn.transform(iff);                           // Value may be known at parse-time
     // Place 'if' on worklist if it will be in graph
     if (!tst->is_Con())  record_for_igvn(iff);     // Range-check and Null-check removal is later
--- a/src/share/vm/opto/idealKit.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/idealKit.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -86,7 +86,7 @@
   }
   // Delay gvn.tranform on if-nodes until construction is finished
   // to prevent a constant bool input from discarding a control output.
-  IfNode* iff = delay_transform(new (C) IfNode(ctrl(), bol, prob, cnt))->as_If();
+  IfNode* iff = delay_transform(new IfNode(ctrl(), bol, prob, cnt))->as_If();
   Node* then  = IfTrue(iff);
   Node* elsen = IfFalse(iff);
   Node* else_cvstate = copy_cvstate();
@@ -205,7 +205,7 @@
   assert(_cvstate != NULL, "must declare variables before labels");
   Node* lab = new_cvstate();
   int sz = 1 + goto_ct + 1 /* fall thru */;
-  Node* reg = delay_transform(new (C) RegionNode(sz));
+  Node* reg = delay_transform(new RegionNode(sz));
   lab->init_req(TypeFunc::Control, reg);
   return lab;
 }
@@ -312,7 +312,7 @@
 //-----------------------------new_cvstate-----------------------------------
 Node* IdealKit::new_cvstate() {
   uint sz = _var_ct + first_var;
-  return new (C) Node(sz);
+  return new Node(sz);
 }
 
 //-----------------------------copy_cvstate-----------------------------------
@@ -397,7 +397,7 @@
 
   // Add required edge to oop_store, optimizer does not support precedence edges.
   // Convert required edge to precedence edge before allocation.
-  Node* st = new (C) StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx);
+  Node* st = new StoreCMNode(ctl, mem, adr, adr_type, val, oop_store, oop_adr_idx);
 
   st = transform(st);
   set_memory(st, adr_idx);
@@ -497,7 +497,7 @@
   uint adr_idx = C->get_alias_index(adr_type);
 
   // Slow-path leaf call
-  CallNode *call =  (CallNode*)new (C) CallLeafNode( slow_call_type, slow_call, leaf_name, adr_type);
+  CallNode *call =  (CallNode*)new CallLeafNode( slow_call_type, slow_call, leaf_name, adr_type);
 
   // Set fixed predefined input arguments
   call->init_req( TypeFunc::Control, ctrl() );
@@ -518,10 +518,10 @@
 
   // Slow leaf call has no side-effects, sets few values
 
-  set_ctrl(transform( new (C) ProjNode(call,TypeFunc::Control) ));
+  set_ctrl(transform( new ProjNode(call,TypeFunc::Control) ));
 
   // Make memory for the call
-  Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
+  Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
 
   // Set the RawPtr memory state only.
   set_memory(mem, adr_idx);
@@ -544,7 +544,7 @@
   uint adr_idx = C->get_alias_index(adr_type);
 
   // Slow-path leaf call
-  CallNode *call =  (CallNode*)new (C) CallLeafNoFPNode( slow_call_type, slow_call, leaf_name, adr_type);
+  CallNode *call =  (CallNode*)new CallLeafNoFPNode( slow_call_type, slow_call, leaf_name, adr_type);
 
   // Set fixed predefined input arguments
   call->init_req( TypeFunc::Control, ctrl() );
@@ -565,10 +565,10 @@
 
   // Slow leaf call has no side-effects, sets few values
 
-  set_ctrl(transform( new (C) ProjNode(call,TypeFunc::Control) ));
+  set_ctrl(transform( new ProjNode(call,TypeFunc::Control) ));
 
   // Make memory for the call
-  Node* mem = _gvn.transform( new (C) ProjNode(call, TypeFunc::Memory) );
+  Node* mem = _gvn.transform( new ProjNode(call, TypeFunc::Memory) );
 
   // Set the RawPtr memory state only.
   set_memory(mem, adr_idx);
--- a/src/share/vm/opto/idealKit.hpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/idealKit.hpp	Fri Jun 20 10:15:08 2014 -0700
@@ -173,43 +173,43 @@
   void goto_(Node* lab, bool bind = false);
   void declarations_done();
 
-  Node* IfTrue(IfNode* iff)  { return transform(new (C) IfTrueNode(iff)); }
-  Node* IfFalse(IfNode* iff) { return transform(new (C) IfFalseNode(iff)); }
+  Node* IfTrue(IfNode* iff)  { return transform(new IfTrueNode(iff)); }
+  Node* IfFalse(IfNode* iff) { return transform(new IfFalseNode(iff)); }
 
   // Data
   Node* ConI(jint k) { return (Node*)gvn().intcon(k); }
   Node* makecon(const Type *t)  const { return _gvn.makecon(t); }
 
-  Node* AddI(Node* l, Node* r) { return transform(new (C) AddINode(l, r)); }
-  Node* SubI(Node* l, Node* r) { return transform(new (C) SubINode(l, r)); }
-  Node* AndI(Node* l, Node* r) { return transform(new (C) AndINode(l, r)); }
-  Node* MaxI(Node* l, Node* r) { return transform(new (C) MaxINode(l, r)); }
-  Node* LShiftI(Node* l, Node* r) { return transform(new (C) LShiftINode(l, r)); }
-  Node* CmpI(Node* l, Node* r) { return transform(new (C) CmpINode(l, r)); }
-  Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new (C) BoolNode(cmp, relop)); }
+  Node* AddI(Node* l, Node* r) { return transform(new AddINode(l, r)); }
+  Node* SubI(Node* l, Node* r) { return transform(new SubINode(l, r)); }
+  Node* AndI(Node* l, Node* r) { return transform(new AndINode(l, r)); }
+  Node* MaxI(Node* l, Node* r) { return transform(new MaxINode(l, r)); }
+  Node* LShiftI(Node* l, Node* r) { return transform(new LShiftINode(l, r)); }
+  Node* CmpI(Node* l, Node* r) { return transform(new CmpINode(l, r)); }
+  Node* Bool(Node* cmp, BoolTest::mask relop) { return transform(new BoolNode(cmp, relop)); }
   void  increment(IdealVariable& v, Node* j)  { set(v, AddI(value(v), j)); }
   void  decrement(IdealVariable& v, Node* j)  { set(v, SubI(value(v), j)); }
 
-  Node* CmpL(Node* l, Node* r) { return transform(new (C) CmpLNode(l, r)); }
+  Node* CmpL(Node* l, Node* r) { return transform(new CmpLNode(l, r)); }
 
   // TLS
-  Node* thread()  {  return gvn().transform(new (C) ThreadLocalNode()); }
+  Node* thread()  {  return gvn().transform(new ThreadLocalNode()); }
 
   // Pointers
 
   // Raw address should be transformed regardless 'delay_transform' flag
   // to produce canonical form CastX2P(offset).
-  Node* AddP(Node *base, Node *ptr, Node *off) { return _gvn.transform(new (C) AddPNode(base, ptr, off)); }
+  Node* AddP(Node *base, Node *ptr, Node *off) { return _gvn.transform(new AddPNode(base, ptr, off)); }
 
-  Node* CmpP(Node* l, Node* r) { return transform(new (C) CmpPNode(l, r)); }
+  Node* CmpP(Node* l, Node* r) { return transform(new CmpPNode(l, r)); }
 #ifdef _LP64
-  Node* XorX(Node* l, Node* r) { return transform(new (C) XorLNode(l, r)); }
+  Node* XorX(Node* l, Node* r) { return transform(new XorLNode(l, r)); }
 #else // _LP64
-  Node* XorX(Node* l, Node* r) { return transform(new (C) XorINode(l, r)); }
+  Node* XorX(Node* l, Node* r) { return transform(new XorINode(l, r)); }
 #endif // _LP64
-  Node* URShiftX(Node* l, Node* r) { return transform(new (C) URShiftXNode(l, r)); }
+  Node* URShiftX(Node* l, Node* r) { return transform(new URShiftXNode(l, r)); }
   Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); }
-  Node* CastPX(Node* ctl, Node* p) { return transform(new (C) CastP2XNode(ctl, p)); }
+  Node* CastPX(Node* ctl, Node* p) { return transform(new CastP2XNode(ctl, p)); }
 
   // Memory operations
 
--- a/src/share/vm/opto/ifnode.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/ifnode.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -238,10 +238,10 @@
   Node* predicate_x = NULL;
   bool counted_loop = r->is_CountedLoop();
 
-  Node *region_c = new (igvn->C) RegionNode(req_c + 1);
+  Node *region_c = new RegionNode(req_c + 1);
   Node *phi_c    = con1;
   uint  len      = r->req();
-  Node *region_x = new (igvn->C) RegionNode(len - req_c);
+  Node *region_x = new RegionNode(len - req_c);
   Node *phi_x    = PhiNode::make_blank(region_x, phi);
   for (uint i = 1, i_c = 1, i_x = 1; i < len; i++) {
     if (phi->in(i) == con1) {
@@ -272,7 +272,7 @@
   // Prevent the untimely death of phi_x.  Currently he has no uses.  He is
   // about to get one.  If this only use goes away, then phi_x will look dead.
   // However, he will be picking up some more uses down below.
-  Node *hook = new (igvn->C) Node(4);
+  Node *hook = new Node(4);
   hook->init_req(0, phi_x);
   hook->init_req(1, phi_c);
   phi_x = phase->transform( phi_x );
@@ -284,30 +284,30 @@
   cmp_x->set_req(2,con2);
   cmp_x = phase->transform(cmp_x);
   // Make the bool
-  Node *b_c = phase->transform(new (igvn->C) BoolNode(cmp_c,b->_test._test));
-  Node *b_x = phase->transform(new (igvn->C) BoolNode(cmp_x,b->_test._test));
+  Node *b_c = phase->transform(new BoolNode(cmp_c,b->_test._test));
+  Node *b_x = phase->transform(new BoolNode(cmp_x,b->_test._test));
   // Make the IfNode
-  IfNode *iff_c = new (igvn->C) IfNode(region_c,b_c,iff->_prob,iff->_fcnt);
+  IfNode *iff_c = new IfNode(region_c,b_c,iff->_prob,iff->_fcnt);
   igvn->set_type_bottom(iff_c);
   igvn->_worklist.push(iff_c);
   hook->init_req(2, iff_c);
 
-  IfNode *iff_x = new (igvn->C) IfNode(region_x,b_x,iff->_prob, iff->_fcnt);
+  IfNode *iff_x = new IfNode(region_x,b_x,iff->_prob, iff->_fcnt);
   igvn->set_type_bottom(iff_x);
   igvn->_worklist.push(iff_x);
   hook->init_req(3, iff_x);
 
   // Make the true/false arms
-  Node *iff_c_t = phase->transform(new (igvn->C) IfTrueNode (iff_c));
-  Node *iff_c_f = phase->transform(new (igvn->C) IfFalseNode(iff_c));
+  Node *iff_c_t = phase->transform(new IfTrueNode (iff_c));
+  Node *iff_c_f = phase->transform(new IfFalseNode(iff_c));
   if (predicate_c != NULL) {
     assert(predicate_x == NULL, "only one predicate entry expected");
     // Clone loop predicates to each path
     iff_c_t = igvn->clone_loop_predicates(predicate_c, iff_c_t, !counted_loop);
     iff_c_f = igvn->clone_loop_predicates(predicate_c, iff_c_f, !counted_loop);
   }
-  Node *iff_x_t = phase->transform(new (igvn->C) IfTrueNode (iff_x));
-  Node *iff_x_f = phase->transform(new (igvn->C) IfFalseNode(iff_x));
+  Node *iff_x_t = phase->transform(new IfTrueNode (iff_x));
+  Node *iff_x_f = phase->transform(new IfFalseNode(iff_x));
   if (predicate_x != NULL) {
     assert(predicate_c == NULL, "only one predicate entry expected");
     // Clone loop predicates to each path
@@ -316,14 +316,14 @@
   }
 
   // Merge the TRUE paths
-  Node *region_s = new (igvn->C) RegionNode(3);
+  Node *region_s = new RegionNode(3);
   igvn->_worklist.push(region_s);
   region_s->init_req(1, iff_c_t);
   region_s->init_req(2, iff_x_t);
   igvn->register_new_node_with_optimizer( region_s );
 
   // Merge the FALSE paths
-  Node *region_f = new (igvn->C) RegionNode(3);
+  Node *region_f = new RegionNode(3);
   igvn->_worklist.push(region_f);
   region_f->init_req(1, iff_c_f);
   region_f->init_req(2, iff_x_f);
@@ -438,7 +438,7 @@
 
   // Must return either the original node (now dead) or a new node
   // (Do not return a top here, since that would break the uniqueness of top.)
-  return new (igvn->C) ConINode(TypeInt::ZERO);
+  return new ConINode(TypeInt::ZERO);
 }
 
 //------------------------------is_range_check---------------------------------
@@ -541,16 +541,16 @@
   // Compute a new check
   Node *new_add = gvn->intcon(off_lo);
   if( index ) {
-    new_add = off_lo ? gvn->transform(new (gvn->C) AddINode( index, new_add )) : index;
+    new_add = off_lo ? gvn->transform(new AddINode( index, new_add )) : index;
   }
   Node *new_cmp = (flip == 1)
-    ? new (gvn->C) CmpUNode( new_add, range )
-    : new (gvn->C) CmpUNode( range, new_add );
+    ? new CmpUNode( new_add, range )
+    : new CmpUNode( range, new_add );
   new_cmp = gvn->transform(new_cmp);
   // See if no need to adjust the existing check
   if( new_cmp == cmp ) return;
   // Else, adjust existing check
-  Node *new_bol = gvn->transform( new (gvn->C) BoolNode( new_cmp, bol->as_Bool()->_test._test ) );
+  Node *new_bol = gvn->transform( new BoolNode( new_cmp, bol->as_Bool()->_test._test ) );
   igvn->rehash_node_delayed( iff );
   iff->set_req_X( 1, new_bol, igvn );
 }
@@ -728,9 +728,9 @@
             if (failtype->_hi != max_jint && failtype->_lo != min_jint && bound > 1) {
               // Merge the two compares into a single unsigned compare by building  (CmpU (n - lo) hi)
               BoolTest::mask cond = fail->as_Proj()->_con ? BoolTest::lt : BoolTest::ge;
-              Node* adjusted = phase->transform(new (phase->C) SubINode(n, phase->intcon(failtype->_lo)));
-              Node* newcmp = phase->transform(new (phase->C) CmpUNode(adjusted, phase->intcon(bound)));
-              Node* newbool = phase->transform(new (phase->C) BoolNode(newcmp, cond));
+              Node* adjusted = phase->transform(new SubINode(n, phase->intcon(failtype->_lo)));
+              Node* newcmp = phase->transform(new CmpUNode(adjusted, phase->intcon(bound)));
+              Node* newbool = phase->transform(new BoolNode(newcmp, cond));
               phase->is_IterGVN()->replace_input_of(dom_iff, 1, phase->intcon(ctrl->as_Proj()->_con));
               phase->hash_delete(this);
               set_req(1, newbool);
@@ -1003,7 +1003,7 @@
 
   // Must return either the original node (now dead) or a new node
   // (Do not return a top here, since that would break the uniqueness of top.)
-  return new (phase->C) ConINode(TypeInt::ZERO);
+  return new ConINode(TypeInt::ZERO);
 }
 
 //------------------------------dominated_by-----------------------------------
@@ -1099,7 +1099,7 @@
 
   // Flip test to be canonical.  Requires flipping the IfFalse/IfTrue and
   // cloning the IfNode.
-  Node* new_b = phase->transform( new (phase->C) BoolNode(b->in(1), bt.negate()) );
+  Node* new_b = phase->transform( new BoolNode(b->in(1), bt.negate()) );
   if( !new_b->is_Bool() ) return NULL;
   b = new_b->as_Bool();
 
@@ -1107,7 +1107,7 @@
   assert( igvn, "Test is not canonical in parser?" );
 
   // The IF node never really changes, but it needs to be cloned
-  iff = new (phase->C) IfNode( iff->in(0), b, 1.0-iff->_prob, iff->_fcnt);
+  iff = new IfNode( iff->in(0), b, 1.0-iff->_prob, iff->_fcnt);
 
   Node *prior = igvn->hash_find_insert(iff);
   if( prior ) {
@@ -1120,8 +1120,8 @@
   igvn->_worklist.push(iff);
 
   // Now handle projections.  Cloning not required.
-  Node* new_if_f = (Node*)(new (phase->C) IfFalseNode( iff ));
-  Node* new_if_t = (Node*)(new (phase->C) IfTrueNode ( iff ));
+  Node* new_if_f = (Node*)(new IfFalseNode( iff ));
+  Node* new_if_t = (Node*)(new IfTrueNode ( iff ));
 
   igvn->register_new_node_with_optimizer(new_if_f);
   igvn->register_new_node_with_optimizer(new_if_t);
--- a/src/share/vm/opto/lcm.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/lcm.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -419,7 +419,7 @@
     Node *tmp2 = block->get_node(block->end_idx()+2);
     block->map_node(tmp2, block->end_idx()+1);
     block->map_node(tmp1, block->end_idx()+2);
-    Node *tmp = new (C) Node(C->top()); // Use not NULL input
+    Node *tmp = new Node(C->top()); // Use not NULL input
     tmp1->replace_by(tmp);
     tmp2->replace_by(tmp1);
     tmp->replace_by(tmp2);
@@ -430,7 +430,7 @@
   // Since schedule-local needs precise def-use info, we need to correct
   // it as well.
   Node *old_tst = proj->in(0);
-  MachNode *nul_chk = new (C) MachNullCheckNode(old_tst->in(0),best,bidx);
+  MachNode *nul_chk = new MachNullCheckNode(old_tst->in(0),best,bidx);
   block->map_node(nul_chk, block->end_idx());
   map_node_to_block(nul_chk, block);
   // Redirect users of old_test to nul_chk
@@ -671,7 +671,7 @@
   // Set all registers killed and not already defined by the call.
   uint r_cnt = mcall->tf()->range()->cnt();
   int op = mcall->ideal_Opcode();
-  MachProjNode *proj = new (C) MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj );
+  MachProjNode *proj = new MachProjNode( mcall, r_cnt+1, RegMask::Empty, MachProjNode::fat_proj );
   map_node_to_block(proj, block);
   block->insert_node(proj, node_cnt++);
 
@@ -900,7 +900,7 @@
       regs.Insert(_matcher.c_frame_pointer());
       regs.OR(n->out_RegMask());
 
-      MachProjNode *proj = new (C) MachProjNode( n, 1, RegMask::Empty, MachProjNode::fat_proj );
+      MachProjNode *proj = new MachProjNode( n, 1, RegMask::Empty, MachProjNode::fat_proj );
       map_node_to_block(proj, block);
       block->insert_node(proj, phi_cnt++);
 
--- a/src/share/vm/opto/library_call.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/library_call.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -52,25 +52,28 @@
  public:
  private:
   bool             _is_virtual;
-  bool             _is_predicted;
   bool             _does_virtual_dispatch;
+  int8_t           _predicates_count;  // Intrinsic is predicated by several conditions
+  int8_t           _last_predicate; // Last generated predicate
   vmIntrinsics::ID _intrinsic_id;
 
  public:
-  LibraryIntrinsic(ciMethod* m, bool is_virtual, bool is_predicted, bool does_virtual_dispatch, vmIntrinsics::ID id)
+  LibraryIntrinsic(ciMethod* m, bool is_virtual, int predicates_count, bool does_virtual_dispatch, vmIntrinsics::ID id)
     : InlineCallGenerator(m),
       _is_virtual(is_virtual),
-      _is_predicted(is_predicted),
       _does_virtual_dispatch(does_virtual_dispatch),
+      _predicates_count((int8_t)predicates_count),
+      _last_predicate((int8_t)-1),
       _intrinsic_id(id)
   {
   }
   virtual bool is_intrinsic() const { return true; }
   virtual bool is_virtual()   const { return _is_virtual; }
-  virtual bool is_predicted()   const { return _is_predicted; }
+  virtual bool is_predicated() const { return _predicates_count > 0; }
+  virtual int  predicates_count() const { return _predicates_count; }
   virtual bool does_virtual_dispatch()   const { return _does_virtual_dispatch; }
-  virtual JVMState* generate(JVMState* jvms, Parse* parent_parser);
-  virtual Node* generate_predicate(JVMState* jvms);
+  virtual JVMState* generate(JVMState* jvms);
+  virtual Node* generate_predicate(JVMState* jvms, int predicate);
   vmIntrinsics::ID intrinsic_id() const { return _intrinsic_id; }
 };
 
@@ -113,8 +116,8 @@
   vmIntrinsics::ID  intrinsic_id() const { return _intrinsic->intrinsic_id(); }
   ciMethod*         callee()    const    { return _intrinsic->method(); }
 
-  bool try_to_inline();
-  Node* try_to_predicate();
+  bool  try_to_inline(int predicate);
+  Node* try_to_predicate(int predicate);
 
   void push_result() {
     // Push the result onto the stack.
@@ -313,6 +316,14 @@
   Node* inline_cipherBlockChaining_AESCrypt_predicate(bool decrypting);
   Node* get_key_start_from_aescrypt_object(Node* aescrypt_object);
   Node* get_original_key_start_from_aescrypt_object(Node* aescrypt_object);
+  bool inline_sha_implCompress(vmIntrinsics::ID id);
+  bool inline_digestBase_implCompressMB(int predicate);
+  bool inline_sha_implCompressMB(Node* digestBaseObj, ciInstanceKlass* instklass_SHA,
+                                 bool long_state, address stubAddr, const char *stubName,
+                                 Node* src_start, Node* ofs, Node* limit);
+  Node* get_state_from_sha_object(Node *sha_object);
+  Node* get_state_from_sha5_object(Node *sha_object);
+  Node* inline_digestBase_implCompressMB_predicate(int predicate);
   bool inline_encodeISOArray();
   bool inline_updateCRC32();
   bool inline_updateBytesCRC32();
@@ -373,7 +384,7 @@
     }
   }
 
-  bool is_predicted = false;
+  int predicates = 0;
   bool does_virtual_dispatch = false;
 
   switch (id) {
@@ -513,7 +524,24 @@
   case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
     if (!UseAESIntrinsics) return NULL;
     // these two require the predicated logic
-    is_predicted = true;
+    predicates = 1;
+    break;
+
+  case vmIntrinsics::_sha_implCompress:
+    if (!UseSHA1Intrinsics) return NULL;
+    break;
+
+  case vmIntrinsics::_sha2_implCompress:
+    if (!UseSHA256Intrinsics) return NULL;
+    break;
+
+  case vmIntrinsics::_sha5_implCompress:
+    if (!UseSHA512Intrinsics) return NULL;
+    break;
+
+  case vmIntrinsics::_digestBase_implCompressMB:
+    if (!(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics)) return NULL;
+    predicates = 3;
     break;
 
   case vmIntrinsics::_updateCRC32:
@@ -582,7 +610,7 @@
     if (!InlineUnsafeOps)  return NULL;
   }
 
-  return new LibraryIntrinsic(m, is_virtual, is_predicted, does_virtual_dispatch, (vmIntrinsics::ID) id);
+  return new LibraryIntrinsic(m, is_virtual, predicates, does_virtual_dispatch, (vmIntrinsics::ID) id);
 }
 
 //----------------------register_library_intrinsics-----------------------
@@ -591,7 +619,7 @@
   // Nothing to do here.
 }
 
-JVMState* LibraryIntrinsic::generate(JVMState* jvms, Parse* parent_parser) {
+JVMState* LibraryIntrinsic::generate(JVMState* jvms) {
   LibraryCallKit kit(jvms, this);
   Compile* C = kit.C;
   int nodes = C->unique();
@@ -606,7 +634,7 @@
   const int bci    = kit.bci();
 
   // Try to inline the intrinsic.
-  if (kit.try_to_inline()) {
+  if (kit.try_to_inline(_last_predicate)) {
     if (C->print_intrinsics() || C->print_inlining()) {
       C->print_inlining(callee, jvms->depth() - 1, bci, is_virtual() ? "(intrinsic, virtual)" : "(intrinsic)");
     }
@@ -641,12 +669,13 @@
   return NULL;
 }
 
-Node* LibraryIntrinsic::generate_predicate(JVMState* jvms) {
+Node* LibraryIntrinsic::generate_predicate(JVMState* jvms, int predicate) {
   LibraryCallKit kit(jvms, this);
   Compile* C = kit.C;
   int nodes = C->unique();
+  _last_predicate = predicate;
 #ifndef PRODUCT
-  assert(is_predicted(), "sanity");
+  assert(is_predicated() && predicate < predicates_count(), "sanity");
   if ((C->print_intrinsics() || C->print_inlining()) && Verbose) {
     char buf[1000];
     const char* str = vmIntrinsics::short_name_as_C_string(intrinsic_id(), buf, sizeof(buf));
@@ -656,10 +685,10 @@
   ciMethod* callee = kit.callee();
   const int bci    = kit.bci();
 
-  Node* slow_ctl = kit.try_to_predicate();
+  Node* slow_ctl = kit.try_to_predicate(predicate);
   if (!kit.failing()) {
     if (C->print_intrinsics() || C->print_inlining()) {
-      C->print_inlining(callee, jvms->depth() - 1, bci, is_virtual() ? "(intrinsic, virtual)" : "(intrinsic)");
+      C->print_inlining(callee, jvms->depth() - 1, bci, is_virtual() ? "(intrinsic, virtual, predicate)" : "(intrinsic, predicate)");
     }
     C->gather_intrinsic_statistics(intrinsic_id(), is_virtual(), Compile::_intrinsic_worked);
     if (C->log()) {
@@ -688,7 +717,7 @@
   return NULL;
 }
 
-bool LibraryCallKit::try_to_inline() {
+bool LibraryCallKit::try_to_inline(int predicate) {
   // Handle symbolic names for otherwise undistinguished boolean switches:
   const bool is_store       = true;
   const bool is_native_ptr  = true;
@@ -882,6 +911,14 @@
   case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
     return inline_cipherBlockChaining_AESCrypt(intrinsic_id());
 
+  case vmIntrinsics::_sha_implCompress:
+  case vmIntrinsics::_sha2_implCompress:
+  case vmIntrinsics::_sha5_implCompress:
+    return inline_sha_implCompress(intrinsic_id());
+
+  case vmIntrinsics::_digestBase_implCompressMB:
+    return inline_digestBase_implCompressMB(predicate);
+
   case vmIntrinsics::_encodeISOArray:
     return inline_encodeISOArray();
 
@@ -905,7 +942,7 @@
   }
 }
 
-Node* LibraryCallKit::try_to_predicate() {
+Node* LibraryCallKit::try_to_predicate(int predicate) {
   if (!jvms()->has_method()) {
     // Root JVMState has a null method.
     assert(map()->memory()->Opcode() == Op_Parm, "");
@@ -919,6 +956,8 @@
     return inline_cipherBlockChaining_AESCrypt_predicate(false);
   case vmIntrinsics::_cipherBlockChaining_decryptAESCrypt:
     return inline_cipherBlockChaining_AESCrypt_predicate(true);
+  case vmIntrinsics::_digestBase_implCompressMB:
+    return inline_digestBase_implCompressMB_predicate(predicate);
 
   default:
     // If you get here, it may be that someone has added a new intrinsic
@@ -969,7 +1008,7 @@
 
   IfNode* iff = create_and_map_if(control(), test, true_prob, COUNT_UNKNOWN);
 
-  Node* if_slow = _gvn.transform(new (C) IfTrueNode(iff));
+  Node* if_slow = _gvn.transform(new IfTrueNode(iff));
   if (if_slow == top()) {
     // The slow branch is never taken.  No need to build this guard.
     return NULL;
@@ -978,7 +1017,7 @@
   if (region != NULL)
     region->add_req(if_slow);
 
-  Node* if_fast = _gvn.transform(new (C) IfFalseNode(iff));
+  Node* if_fast = _gvn.transform(new IfFalseNode(iff));
   set_control(if_fast);
 
   return if_slow;
@@ -997,12 +1036,12 @@
     return NULL;                // already stopped
   if (_gvn.type(index)->higher_equal(TypeInt::POS)) // [0,maxint]
     return NULL;                // index is already adequately typed
-  Node* cmp_lt = _gvn.transform(new (C) CmpINode(index, intcon(0)));
-  Node* bol_lt = _gvn.transform(new (C) BoolNode(cmp_lt, BoolTest::lt));
+  Node* cmp_lt = _gvn.transform(new CmpINode(index, intcon(0)));
+  Node* bol_lt = _gvn.transform(new BoolNode(cmp_lt, BoolTest::lt));
   Node* is_neg = generate_guard(bol_lt, region, PROB_MIN);
   if (is_neg != NULL && pos_index != NULL) {
     // Emulate effect of Parse::adjust_map_after_if.
-    Node* ccast = new (C) CastIINode(index, TypeInt::POS);
+    Node* ccast = new CastIINode(index, TypeInt::POS);
     ccast->set_req(0, control());
     (*pos_index) = _gvn.transform(ccast);
   }
@@ -1015,13 +1054,13 @@
     return NULL;                // already stopped
   if (_gvn.type(index)->higher_equal(TypeInt::POS1)) // [1,maxint]
     return NULL;                // index is already adequately typed
-  Node* cmp_le = _gvn.transform(new (C) CmpINode(index, intcon(0)));
+  Node* cmp_le = _gvn.transform(new CmpINode(index, intcon(0)));
   BoolTest::mask le_or_eq = (never_negative ? BoolTest::eq : BoolTest::le);
-  Node* bol_le = _gvn.transform(new (C) BoolNode(cmp_le, le_or_eq));
+  Node* bol_le = _gvn.transform(new BoolNode(cmp_le, le_or_eq));
   Node* is_notp = generate_guard(bol_le, NULL, PROB_MIN);
   if (is_notp != NULL && pos_index != NULL) {
     // Emulate effect of Parse::adjust_map_after_if.
-    Node* ccast = new (C) CastIINode(index, TypeInt::POS1);
+    Node* ccast = new CastIINode(index, TypeInt::POS1);
     ccast->set_req(0, control());
     (*pos_index) = _gvn.transform(ccast);
   }
@@ -1053,9 +1092,9 @@
     return NULL;                // common case of whole-array copy
   Node* last = subseq_length;
   if (!zero_offset)             // last += offset
-    last = _gvn.transform(new (C) AddINode(last, offset));
-  Node* cmp_lt = _gvn.transform(new (C) CmpUNode(array_length, last));
-  Node* bol_lt = _gvn.transform(new (C) BoolNode(cmp_lt, BoolTest::lt));
+    last = _gvn.transform(new AddINode(last, offset));
+  Node* cmp_lt = _gvn.transform(new CmpUNode(array_length, last));
+  Node* bol_lt = _gvn.transform(new BoolNode(cmp_lt, BoolTest::lt));
   Node* is_over = generate_guard(bol_lt, region, PROB_MIN);
   return is_over;
 }
@@ -1065,7 +1104,7 @@
 Node* LibraryCallKit::generate_current_thread(Node* &tls_output) {
   ciKlass*    thread_klass = env()->Thread_klass();
   const Type* thread_type  = TypeOopPtr::make_from_klass(thread_klass)->cast_to_ptr_type(TypePtr::NotNull);
-  Node* thread = _gvn.transform(new (C) ThreadLocalNode());
+  Node* thread = _gvn.transform(new ThreadLocalNode());
   Node* p = basic_plus_adr(top()/*!oop*/, thread, in_bytes(JavaThread::threadObj_offset()));
   Node* threadObj = make_load(NULL, p, thread_type, T_OBJECT, MemNode::unordered);
   tls_output = thread;
@@ -1100,18 +1139,18 @@
     // Get length of string 2
     str2_len = load_String_length(no_ctrl, str2);
 
-    result = new (C) StrIndexOfNode(control(), memory(TypeAryPtr::CHARS),
-                                 str1_start, str1_len, str2_start, str2_len);
+    result = new StrIndexOfNode(control(), memory(TypeAryPtr::CHARS),
+                                str1_start, str1_len, str2_start, str2_len);
     break;
   case Op_StrComp:
     // Get length of string 2
     str2_len = load_String_length(no_ctrl, str2);
 
-    result = new (C) StrCompNode(control(), memory(TypeAryPtr::CHARS),
-                                 str1_start, str1_len, str2_start, str2_len);
+    result = new StrCompNode(control(), memory(TypeAryPtr::CHARS),
+                             str1_start, str1_len, str2_start, str2_len);
     break;
   case Op_StrEquals:
-    result = new (C) StrEqualsNode(control(), memory(TypeAryPtr::CHARS),
+    result = new StrEqualsNode(control(), memory(TypeAryPtr::CHARS),
                                str1_start, str2_start, str1_len);
     break;
   default:
@@ -1133,16 +1172,16 @@
   Node* result = NULL;
   switch (opcode) {
   case Op_StrIndexOf:
-    result = new (C) StrIndexOfNode(control(), memory(TypeAryPtr::CHARS),
-                                 str1_start, cnt1, str2_start, cnt2);
+    result = new StrIndexOfNode(control(), memory(TypeAryPtr::CHARS),
+                                str1_start, cnt1, str2_start, cnt2);
     break;
   case Op_StrComp:
-    result = new (C) StrCompNode(control(), memory(TypeAryPtr::CHARS),
-                                 str1_start, cnt1, str2_start, cnt2);
+    result = new StrCompNode(control(), memory(TypeAryPtr::CHARS),
+                             str1_start, cnt1, str2_start, cnt2);
     break;
   case Op_StrEquals:
-    result = new (C) StrEqualsNode(control(), memory(TypeAryPtr::CHARS),
-                                 str1_start, str2_start, cnt1);
+    result = new StrEqualsNode(control(), memory(TypeAryPtr::CHARS),
+                               str1_start, str2_start, cnt1);
     break;
   default:
     ShouldNotReachHere();
@@ -1178,12 +1217,12 @@
   }
 
   // paths (plus control) merge
-  RegionNode* region = new (C) RegionNode(5);
-  Node* phi = new (C) PhiNode(region, TypeInt::BOOL);
+  RegionNode* region = new RegionNode(5);
+  Node* phi = new PhiNode(region, TypeInt::BOOL);
 
   // does source == target string?
-  Node* cmp = _gvn.transform(new (C) CmpPNode(receiver, argument));
-  Node* bol = _gvn.transform(new (C) BoolNode(cmp, BoolTest::eq));
+  Node* cmp = _gvn.transform(new CmpPNode(receiver, argument));
+  Node* bol = _gvn.transform(new BoolNode(cmp, BoolTest::eq));
 
   Node* if_eq = generate_slow_guard(bol, NULL);
   if (if_eq != NULL) {
@@ -1197,8 +1236,8 @@
 
   if (!stopped()) {
     Node* inst = gen_instanceof(argument, makecon(TypeKlassPtr::make(klass)));
-    Node* cmp  = _gvn.transform(new (C) CmpINode(inst, intcon(1)));
-    Node* bol  = _gvn.transform(new (C) BoolNode(cmp, BoolTest::ne));
+    Node* cmp  = _gvn.transform(new CmpINode(inst, intcon(1)));
+    Node* bol  = _gvn.transform(new BoolNode(cmp, BoolTest::ne));
 
     Node* inst_false = generate_guard(bol, NULL, PROB_MIN);
     //instanceOf == true, fallthrough
@@ -1213,7 +1252,7 @@
     const TypeOopPtr* string_type = TypeOopPtr::make_from_klass(klass);
 
     // Properly cast the argument to String
-    argument = _gvn.transform(new (C) CheckCastPPNode(control(), argument, string_type));
+    argument = _gvn.transform(new CheckCastPPNode(control(), argument, string_type));
     // This path is taken only when argument's type is String:NotNull.
     argument = cast_not_null(argument, false);
 
@@ -1236,8 +1275,8 @@
     Node* argument_cnt  = load_String_length(no_ctrl, argument);
 
     // Check for receiver count != argument count
-    Node* cmp = _gvn.transform(new(C) CmpINode(receiver_cnt, argument_cnt));
-    Node* bol = _gvn.transform(new(C) BoolNode(cmp, BoolTest::ne));
+    Node* cmp = _gvn.transform(new CmpINode(receiver_cnt, argument_cnt));
+    Node* bol = _gvn.transform(new BoolNode(cmp, BoolTest::ne));
     Node* if_ne = generate_slow_guard(bol, NULL);
     if (if_ne != NULL) {
       phi->init_req(4, intcon(0));
@@ -1265,7 +1304,7 @@
 bool LibraryCallKit::inline_array_equals() {
   Node* arg1 = argument(0);
   Node* arg2 = argument(1);
-  set_result(_gvn.transform(new (C) AryEqNode(control(), memory(TypeAryPtr::CHARS), arg1, arg2)));
+  set_result(_gvn.transform(new AryEqNode(control(), memory(TypeAryPtr::CHARS), arg1, arg2)));
   return true;
 }
 
@@ -1434,8 +1473,8 @@
     const TypeOopPtr* string_type = TypeOopPtr::make_from_klass(str_klass);
 
     // Make the merge point
-    RegionNode* result_rgn = new (C) RegionNode(4);
-    Node*       result_phi = new (C) PhiNode(result_rgn, TypeInt::INT);
+    RegionNode* result_rgn = new RegionNode(4);
+    Node*       result_phi = new PhiNode(result_rgn, TypeInt::INT);
     Node* no_ctrl  = NULL;
 
     // Get start addr of source string
@@ -1455,8 +1494,8 @@
     Node* substr_cnt  = load_String_length(no_ctrl, arg);
 
     // Check for substr count > string count
-    Node* cmp = _gvn.transform(new(C) CmpINode(substr_cnt, source_cnt));
-    Node* bol = _gvn.transform(new(C) BoolNode(cmp, BoolTest::gt));
+    Node* cmp = _gvn.transform(new CmpINode(substr_cnt, source_cnt));
+    Node* bol = _gvn.transform(new BoolNode(cmp, BoolTest::gt));
     Node* if_gt = generate_slow_guard(bol, NULL);
     if (if_gt != NULL) {
       result_phi->init_req(2, intcon(-1));
@@ -1465,8 +1504,8 @@
 
     if (!stopped()) {
       // Check for substr count == 0
-      cmp = _gvn.transform(new(C) CmpINode(substr_cnt, intcon(0)));
-      bol = _gvn.transform(new(C) BoolNode(cmp, BoolTest::eq));
+      cmp = _gvn.transform(new CmpINode(substr_cnt, intcon(0)));
+      bol = _gvn.transform(new BoolNode(cmp, BoolTest::eq));
       Node* if_zero = generate_slow_guard(bol, NULL);
       if (if_zero != NULL) {
         result_phi->init_req(3, intcon(0));
@@ -1558,7 +1597,7 @@
 // Round a double node if necessary.
 Node* LibraryCallKit::round_double_node(Node* n) {
   if (Matcher::strict_fp_requires_explicit_rounding && UseSSE <= 1)
-    n = _gvn.transform(new (C) RoundDoubleNode(0, n));
+    n = _gvn.transform(new RoundDoubleNode(0, n));
   return n;
 }
 
@@ -1571,10 +1610,10 @@
   Node* arg = round_double_node(argument(0));
   Node* n;
   switch (id) {
-  case vmIntrinsics::_dabs:   n = new (C) AbsDNode(                arg);  break;
-  case vmIntrinsics::_dsqrt:  n = new (C) SqrtDNode(C, control(),  arg);  break;
-  case vmIntrinsics::_dlog:   n = new (C) LogDNode(C, control(),   arg);  break;
-  case vmIntrinsics::_dlog10: n = new (C) Log10DNode(C, control(), arg);  break;
+  case vmIntrinsics::_dabs:   n = new AbsDNode(                arg);  break;
+  case vmIntrinsics::_dsqrt:  n = new SqrtDNode(C, control(),  arg);  break;
+  case vmIntrinsics::_dlog:   n = new LogDNode(C, control(),   arg);  break;
+  case vmIntrinsics::_dlog10: n = new Log10DNode(C, control(), arg);  break;
   default:  fatal_unexpected_iid(id);  break;
   }
   set_result(_gvn.transform(n));
@@ -1589,9 +1628,9 @@
   Node* n = NULL;
 
   switch (id) {
-  case vmIntrinsics::_dsin:  n = new (C) SinDNode(C, control(), arg);  break;
-  case vmIntrinsics::_dcos:  n = new (C) CosDNode(C, control(), arg);  break;
-  case vmIntrinsics::_dtan:  n = new (C) TanDNode(C, control(), arg);  break;
+  case vmIntrinsics::_dsin:  n = new SinDNode(C, control(), arg);  break;
+  case vmIntrinsics::_dcos:  n = new CosDNode(C, control(), arg);  break;
+  case vmIntrinsics::_dtan:  n = new TanDNode(C, control(), arg);  break;
   default:  fatal_unexpected_iid(id);  break;
   }
   n = _gvn.transform(n);
@@ -1632,17 +1671,17 @@
     // probably do the math inside the SIN encoding.
 
     // Make the merge point
-    RegionNode* r = new (C) RegionNode(3);
-    Node* phi = new (C) PhiNode(r, Type::DOUBLE);
+    RegionNode* r = new RegionNode(3);
+    Node* phi = new PhiNode(r, Type::DOUBLE);
 
     // Flatten arg so we need only 1 test
-    Node *abs = _gvn.transform(new (C) AbsDNode(arg));
+    Node *abs = _gvn.transform(new AbsDNode(arg));
     // Node for PI/4 constant
     Node *pi4 = makecon(TypeD::make(pi_4));
     // Check PI/4 : abs(arg)
-    Node *cmp = _gvn.transform(new (C) CmpDNode(pi4,abs));
+    Node *cmp = _gvn.transform(new CmpDNode(pi4,abs));
     // Check: If PI/4 < abs(arg) then go slow
-    Node *bol = _gvn.transform(new (C) BoolNode( cmp, BoolTest::lt ));
+    Node *bol = _gvn.transform(new BoolNode( cmp, BoolTest::lt ));
     // Branch either way
     IfNode *iff = create_and_xform_if(control(),bol, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
     set_control(opt_iff(r,iff));
@@ -1670,7 +1709,7 @@
       break;
     }
     assert(control()->in(0) == call, "");
-    Node* slow_result = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+    Node* slow_result = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
     r->init_req(1, control());
     phi->init_req(1, slow_result);
 
@@ -1690,9 +1729,9 @@
   //result=(result.isNaN())? funcAddr():result;
   // Check: If isNaN() by checking result!=result? then either trap
   // or go to runtime
-  Node* cmpisnan = _gvn.transform(new (C) CmpDNode(result, result));
+  Node* cmpisnan = _gvn.transform(new CmpDNode(result, result));
   // Build the boolean node
-  Node* bolisnum = _gvn.transform(new (C) BoolNode(cmpisnan, BoolTest::eq));
+  Node* bolisnum = _gvn.transform(new BoolNode(cmpisnan, BoolTest::eq));
 
   if (!too_many_traps(Deoptimization::Reason_intrinsic)) {
     { BuildCutout unless(this, bolisnum, PROB_STATIC_FREQUENT);
@@ -1707,12 +1746,12 @@
     // to the runtime to properly handle corner cases
 
     IfNode* iff = create_and_xform_if(control(), bolisnum, PROB_STATIC_FREQUENT, COUNT_UNKNOWN);
-    Node* if_slow = _gvn.transform(new (C) IfFalseNode(iff));
-    Node* if_fast = _gvn.transform(new (C) IfTrueNode(iff));
+    Node* if_slow = _gvn.transform(new IfFalseNode(iff));
+    Node* if_fast = _gvn.transform(new IfTrueNode(iff));
 
     if (!if_slow->is_top()) {
-      RegionNode* result_region = new (C) RegionNode(3);
-      PhiNode*    result_val = new (C) PhiNode(result_region, Type::DOUBLE);
+      RegionNode* result_region = new RegionNode(3);
+      PhiNode*    result_val = new PhiNode(result_region, Type::DOUBLE);
 
       result_region->init_req(1, if_fast);
       result_val->init_req(1, result);
@@ -1723,9 +1762,9 @@
       Node* rt = make_runtime_call(RC_LEAF, call_type, funcAddr, funcName,
                                    no_memory_effects,
                                    x, top(), y, y ? top() : NULL);
-      Node* value = _gvn.transform(new (C) ProjNode(rt, TypeFunc::Parms+0));
+      Node* value = _gvn.transform(new ProjNode(rt, TypeFunc::Parms+0));
 #ifdef ASSERT
-      Node* value_top = _gvn.transform(new (C) ProjNode(rt, TypeFunc::Parms+1));
+      Node* value_top = _gvn.transform(new ProjNode(rt, TypeFunc::Parms+1));
       assert(value_top == top(), "second value must be top");
 #endif
 
@@ -1744,7 +1783,7 @@
 // really odd corner cases (+/- Infinity).  Just uncommon-trap them.
 bool LibraryCallKit::inline_exp() {
   Node* arg = round_double_node(argument(0));
-  Node* n   = _gvn.transform(new (C) ExpDNode(C, control(), arg));
+  Node* n   = _gvn.transform(new ExpDNode(C, control(), arg));
 
   n = finish_pow_exp(n, arg, NULL, OptoRuntime::Math_D_D_Type(), CAST_FROM_FN_PTR(address, SharedRuntime::dexp), "EXP");
   set_result(n);
@@ -1783,76 +1822,76 @@
   Node* result = NULL;
 
   Node*   const_two_node = makecon(TypeD::make(2.0));
-  Node*   cmp_node       = _gvn.transform(new (C) CmpDNode(y, const_two_node));
-  Node*   bool_node      = _gvn.transform(new (C) BoolNode(cmp_node, BoolTest::eq));
+  Node*   cmp_node       = _gvn.transform(new CmpDNode(y, const_two_node));
+  Node*   bool_node      = _gvn.transform(new BoolNode(cmp_node, BoolTest::eq));
   IfNode* if_node        = create_and_xform_if(control(), bool_node, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
-  Node*   if_true        = _gvn.transform(new (C) IfTrueNode(if_node));
-  Node*   if_false       = _gvn.transform(new (C) IfFalseNode(if_node));
-
-  RegionNode* region_node = new (C) RegionNode(3);
+  Node*   if_true        = _gvn.transform(new IfTrueNode(if_node));
+  Node*   if_false       = _gvn.transform(new IfFalseNode(if_node));
+
+  RegionNode* region_node = new RegionNode(3);
   region_node->init_req(1, if_true);
 
-  Node* phi_node = new (C) PhiNode(region_node, Type::DOUBLE);
+  Node* phi_node = new PhiNode(region_node, Type::DOUBLE);
   // special case for x^y where y == 2, we can convert it to x * x
-  phi_node->init_req(1, _gvn.transform(new (C) MulDNode(x, x)));
+  phi_node->init_req(1, _gvn.transform(new MulDNode(x, x)));
 
   // set control to if_false since we will now process the false branch
   set_control(if_false);
 
   if (!too_many_traps(Deoptimization::Reason_intrinsic)) {
     // Short form: skip the fancy tests and just check for NaN result.
-    result = _gvn.transform(new (C) PowDNode(C, control(), x, y));
+    result = _gvn.transform(new PowDNode(C, control(), x, y));
   } else {
     // If this inlining ever returned NaN in the past, include all
     // checks + call to the runtime.
 
     // Set the merge point for If node with condition of (x <= 0.0)
     // There are four possible paths to region node and phi node
-    RegionNode *r = new (C) RegionNode(4);
-    Node *phi = new (C) PhiNode(r, Type::DOUBLE);
+    RegionNode *r = new RegionNode(4);
+    Node *phi = new PhiNode(r, Type::DOUBLE);
 
     // Build the first if node: if (x <= 0.0)
     // Node for 0 constant
     Node *zeronode = makecon(TypeD::ZERO);
     // Check x:0
-    Node *cmp = _gvn.transform(new (C) CmpDNode(x, zeronode));
+    Node *cmp = _gvn.transform(new CmpDNode(x, zeronode));
     // Check: If (x<=0) then go complex path
-    Node *bol1 = _gvn.transform(new (C) BoolNode( cmp, BoolTest::le ));
+    Node *bol1 = _gvn.transform(new BoolNode( cmp, BoolTest::le ));
     // Branch either way
     IfNode *if1 = create_and_xform_if(control(),bol1, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
     // Fast path taken; set region slot 3
-    Node *fast_taken = _gvn.transform(new (C) IfFalseNode(if1));
+    Node *fast_taken = _gvn.transform(new IfFalseNode(if1));
     r->init_req(3,fast_taken); // Capture fast-control
 
     // Fast path not-taken, i.e. slow path
-    Node *complex_path = _gvn.transform(new (C) IfTrueNode(if1));
+    Node *complex_path = _gvn.transform(new IfTrueNode(if1));
 
     // Set fast path result
-    Node *fast_result = _gvn.transform(new (C) PowDNode(C, control(), x, y));
+    Node *fast_result = _gvn.transform(new PowDNode(C, control(), x, y));
     phi->init_req(3, fast_result);
 
     // Complex path
     // Build the second if node (if y is long)
     // Node for (long)y
-    Node *longy = _gvn.transform(new (C) ConvD2LNode(y));
+    Node *longy = _gvn.transform(new ConvD2LNode(y));
     // Node for (double)((long) y)
-    Node *doublelongy= _gvn.transform(new (C) ConvL2DNode(longy));
+    Node *doublelongy= _gvn.transform(new ConvL2DNode(longy));
     // Check (double)((long) y) : y
-    Node *cmplongy= _gvn.transform(new (C) CmpDNode(doublelongy, y));
+    Node *cmplongy= _gvn.transform(new CmpDNode(doublelongy, y));
     // Check if (y isn't long) then go to slow path
 
-    Node *bol2 = _gvn.transform(new (C) BoolNode( cmplongy, BoolTest::ne ));
+    Node *bol2 = _gvn.transform(new BoolNode( cmplongy, BoolTest::ne ));
     // Branch either way
     IfNode *if2 = create_and_xform_if(complex_path,bol2, PROB_STATIC_INFREQUENT, COUNT_UNKNOWN);
-    Node* ylong_path = _gvn.transform(new (C) IfFalseNode(if2));
-
-    Node *slow_path = _gvn.transform(new (C) IfTrueNode(if2));
+    Node* ylong_path = _gvn.transform(new IfFalseNode(if2));
+
+    Node *slow_path = _gvn.transform(new IfTrueNode(if2));
 
     // Calculate DPow(abs(x), y)*(1 & (long)y)
     // Node for constant 1
     Node *conone = longcon(1);
     // 1& (long)y
-    Node *signnode= _gvn.transform(new (C) AndLNode(conone, longy));
+    Node *signnode= _gvn.transform(new AndLNode(conone, longy));
 
     // A huge number is always even. Detect a huge number by checking
     // if y + 1 == y and set integer to be tested for parity to 0.
@@ -1860,18 +1899,18 @@
     // (long)9.223372036854776E18 = max_jlong
     // (double)(long)9.223372036854776E18 = 9.223372036854776E18
     // max_jlong is odd but 9.223372036854776E18 is even
-    Node* yplus1 = _gvn.transform(new (C) AddDNode(y, makecon(TypeD::make(1))));
-    Node *cmpyplus1= _gvn.transform(new (C) CmpDNode(yplus1, y));
-    Node *bolyplus1 = _gvn.transform(new (C) BoolNode( cmpyplus1, BoolTest::eq ));
+    Node* yplus1 = _gvn.transform(new AddDNode(y, makecon(TypeD::make(1))));
+    Node *cmpyplus1= _gvn.transform(new CmpDNode(yplus1, y));
+    Node *bolyplus1 = _gvn.transform(new BoolNode( cmpyplus1, BoolTest::eq ));
     Node* correctedsign = NULL;
     if (ConditionalMoveLimit != 0) {
       correctedsign = _gvn.transform( CMoveNode::make(C, NULL, bolyplus1, signnode, longcon(0), TypeLong::LONG));
     } else {
       IfNode *ifyplus1 = create_and_xform_if(ylong_path,bolyplus1, PROB_FAIR, COUNT_UNKNOWN);
-      RegionNode *r = new (C) RegionNode(3);
-      Node *phi = new (C) PhiNode(r, TypeLong::LONG);
-      r->init_req(1, _gvn.transform(new (C) IfFalseNode(ifyplus1)));
-      r->init_req(2, _gvn.transform(new (C) IfTrueNode(ifyplus1)));
+      RegionNode *r = new RegionNode(3);
+      Node *phi = new PhiNode(r, TypeLong::LONG);
+      r->init_req(1, _gvn.transform(new IfFalseNode(ifyplus1)));
+      r->init_req(2, _gvn.transform(new IfTrueNode(ifyplus1)));
       phi->init_req(1, signnode);
       phi->init_req(2, longcon(0));
       correctedsign = _gvn.transform(phi);
@@ -1882,25 +1921,25 @@
     // zero node
     Node *conzero = longcon(0);
     // Check (1&(long)y)==0?
-    Node *cmpeq1 = _gvn.transform(new (C) CmpLNode(correctedsign, conzero));
+    Node *cmpeq1 = _gvn.transform(new CmpLNode(correctedsign, conzero));
     // Check if (1&(long)y)!=0?, if so the result is negative
-    Node *bol3 = _gvn.transform(new (C) BoolNode( cmpeq1, BoolTest::ne ));
+    Node *bol3 = _gvn.transform(new BoolNode( cmpeq1, BoolTest::ne ));
     // abs(x)
-    Node *absx=_gvn.transform(new (C) AbsDNode(x));
+    Node *absx=_gvn.transform(new AbsDNode(x));
     // abs(x)^y
-    Node *absxpowy = _gvn.transform(new (C) PowDNode(C, control(), absx, y));
+    Node *absxpowy = _gvn.transform(new PowDNode(C, control(), absx, y));
     // -abs(x)^y
-    Node *negabsxpowy = _gvn.transform(new (C) NegDNode (absxpowy));
+    Node *negabsxpowy = _gvn.transform(new NegDNode (absxpowy));
     // (1&(long)y)==1?-DPow(abs(x), y):DPow(abs(x), y)
     Node *signresult = NULL;
     if (ConditionalMoveLimit != 0) {
       signresult = _gvn.transform( CMoveNode::make(C, NULL, bol3, absxpowy, negabsxpowy, Type::DOUBLE));
     } else {
       IfNode *ifyeven = create_and_xform_if(ylong_path,bol3, PROB_FAIR, COUNT_UNKNOWN);
-      RegionNode *r = new (C) RegionNode(3);
-      Node *phi = new (C) PhiNode(r, Type::DOUBLE);
-      r->init_req(1, _gvn.transform(new (C) IfFalseNode(ifyeven)));
-      r->init_req(2, _gvn.transform(new (C) IfTrueNode(ifyeven)));
+      RegionNode *r = new RegionNode(3);
+      Node *phi = new PhiNode(r, Type::DOUBLE);
+      r->init_req(1, _gvn.transform(new IfFalseNode(ifyeven)));
+      r->init_req(2, _gvn.transform(new IfTrueNode(ifyeven)));
       phi->init_req(1, absxpowy);
       phi->init_req(2, negabsxpowy);
       signresult = _gvn.transform(phi);
@@ -1949,9 +1988,9 @@
   Node* trig = make_runtime_call(RC_LEAF, call_type, funcAddr, funcName,
                                  no_memory_effects,
                                  a, top(), b, b ? top() : NULL);
-  Node* value = _gvn.transform(new (C) ProjNode(trig, TypeFunc::Parms+0));
+  Node* value = _gvn.transform(new ProjNode(trig, TypeFunc::Parms+0));
 #ifdef ASSERT
-  Node* value_top = _gvn.transform(new (C) ProjNode(trig, TypeFunc::Parms+1));
+  Node* value_top = _gvn.transform(new ProjNode(trig, TypeFunc::Parms+1));
   assert(value_top == top(), "second value must be top");
 #endif
 
@@ -2011,10 +2050,10 @@
 }
 
 void LibraryCallKit::inline_math_mathExact(Node* math, Node *test) {
-  Node* bol = _gvn.transform( new (C) BoolNode(test, BoolTest::overflow) );
+  Node* bol = _gvn.transform( new BoolNode(test, BoolTest::overflow) );
   IfNode* check = create_and_map_if(control(), bol, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
-  Node* fast_path = _gvn.transform( new (C) IfFalseNode(check));
-  Node* slow_path = _gvn.transform( new (C) IfTrueNode(check) );
+  Node* fast_path = _gvn.transform( new IfFalseNode(check));
+  Node* slow_path = _gvn.transform( new IfTrueNode(check) );
 
   {
     PreserveJVMState pjvms(this);
@@ -2036,9 +2075,9 @@
 bool LibraryCallKit::inline_math_overflow(Node* arg1, Node* arg2) {
   typedef typename OverflowOp::MathOp MathOp;
 
-  MathOp* mathOp = new(C) MathOp(arg1, arg2);
+  MathOp* mathOp = new MathOp(arg1, arg2);
   Node* operation = _gvn.transform( mathOp );
-  Node* ofcheck = _gvn.transform( new(C) OverflowOp(arg1, arg2) );
+  Node* ofcheck = _gvn.transform( new OverflowOp(arg1, arg2) );
   inline_math_mathExact(operation, ofcheck);
   return true;
 }
@@ -2106,7 +2145,7 @@
   int   cmp_op = Op_CmpI;
   Node* xkey = xvalue;
   Node* ykey = yvalue;
-  Node* ideal_cmpxy = _gvn.transform(new(C) CmpINode(xkey, ykey));
+  Node* ideal_cmpxy = _gvn.transform(new CmpINode(xkey, ykey));
   if (ideal_cmpxy->is_Cmp()) {
     // E.g., if we have CmpI(length - offset, count),
     // it might idealize to CmpI(length, count + offset)
@@ -2199,7 +2238,7 @@
   default:
     if (cmpxy == NULL)
       cmpxy = ideal_cmpxy;
-    best_bol = _gvn.transform(new(C) BoolNode(cmpxy, BoolTest::lt));
+    best_bol = _gvn.transform(new BoolNode(cmpxy, BoolTest::lt));
     // and fall through:
   case BoolTest::lt:          // x < y
   case BoolTest::le:          // x <= y
@@ -2259,7 +2298,7 @@
     return Type::AnyPtr;
   } else if (base_type == TypePtr::NULL_PTR) {
     // Since this is a NULL+long form, we have to switch to a rawptr.
-    base   = _gvn.transform(new (C) CastX2PNode(offset));
+    base   = _gvn.transform(new CastX2PNode(offset));
     offset = MakeConX(0);
     return Type::RawPtr;
   } else if (base_type->base() == Type::RawPtr) {
@@ -2312,16 +2351,16 @@
   Node* arg = argument(0);
   Node* n;
   switch (id) {
-  case vmIntrinsics::_numberOfLeadingZeros_i:   n = new (C) CountLeadingZerosINode( arg);  break;
-  case vmIntrinsics::_numberOfLeadingZeros_l:   n = new (C) CountLeadingZerosLNode( arg);  break;
-  case vmIntrinsics::_numberOfTrailingZeros_i:  n = new (C) CountTrailingZerosINode(arg);  break;
-  case vmIntrinsics::_numberOfTrailingZeros_l:  n = new (C) CountTrailingZerosLNode(arg);  break;
-  case vmIntrinsics::_bitCount_i:               n = new (C) PopCountINode(          arg);  break;
-  case vmIntrinsics::_bitCount_l:               n = new (C) PopCountLNode(          arg);  break;
-  case vmIntrinsics::_reverseBytes_c:           n = new (C) ReverseBytesUSNode(0,   arg);  break;
-  case vmIntrinsics::_reverseBytes_s:           n = new (C) ReverseBytesSNode( 0,   arg);  break;
-  case vmIntrinsics::_reverseBytes_i:           n = new (C) ReverseBytesINode( 0,   arg);  break;
-  case vmIntrinsics::_reverseBytes_l:           n = new (C) ReverseBytesLNode( 0,   arg);  break;
+  case vmIntrinsics::_numberOfLeadingZeros_i:   n = new CountLeadingZerosINode( arg);  break;
+  case vmIntrinsics::_numberOfLeadingZeros_l:   n = new CountLeadingZerosLNode( arg);  break;
+  case vmIntrinsics::_numberOfTrailingZeros_i:  n = new CountTrailingZerosINode(arg);  break;
+  case vmIntrinsics::_numberOfTrailingZeros_l:  n = new CountTrailingZerosLNode(arg);  break;
+  case vmIntrinsics::_bitCount_i:               n = new PopCountINode(          arg);  break;
+  case vmIntrinsics::_bitCount_l:               n = new PopCountLNode(          arg);  break;
+  case vmIntrinsics::_reverseBytes_c:           n = new ReverseBytesUSNode(0,   arg);  break;
+  case vmIntrinsics::_reverseBytes_s:           n = new ReverseBytesSNode( 0,   arg);  break;
+  case vmIntrinsics::_reverseBytes_i:           n = new ReverseBytesINode( 0,   arg);  break;
+  case vmIntrinsics::_reverseBytes_l:           n = new ReverseBytesLNode( 0,   arg);  break;
   default:  fatal_unexpected_iid(id);  break;
   }
   set_result(_gvn.transform(n));
@@ -2637,7 +2676,7 @@
       break;
     case T_ADDRESS:
       // Cast to an int type.
-      p = _gvn.transform(new (C) CastP2XNode(NULL, p));
+      p = _gvn.transform(new CastP2XNode(NULL, p));
       p = ConvX2UL(p);
       break;
     default:
@@ -2658,7 +2697,7 @@
     case T_ADDRESS:
       // Repackage the long as a pointer.
       val = ConvL2X(val);
-      val = _gvn.transform(new (C) CastX2PNode(val));
+      val = _gvn.transform(new CastX2PNode(val));
       break;
     }
 
@@ -2766,9 +2805,9 @@
   // Generate the read or write prefetch
   Node *prefetch;
   if (is_store) {
-    prefetch = new (C) PrefetchWriteNode(i_o(), adr);
+    prefetch = new PrefetchWriteNode(i_o(), adr);
   } else {
-    prefetch = new (C) PrefetchReadNode(i_o(), adr);
+    prefetch = new PrefetchReadNode(i_o(), adr);
   }
   prefetch->init_req(0, control());
   set_i_o(_gvn.transform(prefetch));
@@ -2906,22 +2945,22 @@
   switch(type) {
   case T_INT:
     if (kind == LS_xadd) {
-      load_store = _gvn.transform(new (C) GetAndAddINode(control(), mem, adr, newval, adr_type));
+      load_store = _gvn.transform(new GetAndAddINode(control(), mem, adr, newval, adr_type));
     } else if (kind == LS_xchg) {
-      load_store = _gvn.transform(new (C) GetAndSetINode(control(), mem, adr, newval, adr_type));
+      load_store = _gvn.transform(new GetAndSetINode(control(), mem, adr, newval, adr_type));
     } else if (kind == LS_cmpxchg) {
-      load_store = _gvn.transform(new (C) CompareAndSwapINode(control(), mem, adr, newval, oldval));
+      load_store = _gvn.transform(new CompareAndSwapINode(control(), mem, adr, newval, oldval));
     } else {
       ShouldNotReachHere();
     }
     break;
   case T_LONG:
     if (kind == LS_xadd) {
-      load_store = _gvn.transform(new (C) GetAndAddLNode(control(), mem, adr, newval, adr_type));
+      load_store = _gvn.transform(new GetAndAddLNode(control(), mem, adr, newval, adr_type));
     } else if (kind == LS_xchg) {
-      load_store = _gvn.transform(new (C) GetAndSetLNode(control(), mem, adr, newval, adr_type));
+      load_store = _gvn.transform(new GetAndSetLNode(control(), mem, adr, newval, adr_type));
     } else if (kind == LS_cmpxchg) {
-      load_store = _gvn.transform(new (C) CompareAndSwapLNode(control(), mem, adr, newval, oldval));
+      load_store = _gvn.transform(new CompareAndSwapLNode(control(), mem, adr, newval, oldval));
     } else {
       ShouldNotReachHere();
     }
@@ -2958,24 +2997,24 @@
 
 #ifdef _LP64
     if (adr->bottom_type()->is_ptr_to_narrowoop()) {
-      Node *newval_enc = _gvn.transform(new (C) EncodePNode(newval, newval->bottom_type()->make_narrowoop()));
+      Node *newval_enc = _gvn.transform(new EncodePNode(newval, newval->bottom_type()->make_narrowoop()));
       if (kind == LS_xchg) {
-        load_store = _gvn.transform(new (C) GetAndSetNNode(control(), mem, adr,
-                                                           newval_enc, adr_type, value_type->make_narrowoop()));
+        load_store = _gvn.transform(new GetAndSetNNode(control(), mem, adr,
+                                                       newval_enc, adr_type, value_type->make_narrowoop()));
       } else {
         assert(kind == LS_cmpxchg, "wrong LoadStore operation");
-        Node *oldval_enc = _gvn.transform(new (C) EncodePNode(oldval, oldval->bottom_type()->make_narrowoop()));
-        load_store = _gvn.transform(new (C) CompareAndSwapNNode(control(), mem, adr,
+        Node *oldval_enc = _gvn.transform(new EncodePNode(oldval, oldval->bottom_type()->make_narrowoop()));
+        load_store = _gvn.transform(new CompareAndSwapNNode(control(), mem, adr,
                                                                 newval_enc, oldval_enc));
       }
     } else
 #endif
     {
       if (kind == LS_xchg) {
-        load_store = _gvn.transform(new (C) GetAndSetPNode(control(), mem, adr, newval, adr_type, value_type->is_oopptr()));
+        load_store = _gvn.transform(new GetAndSetPNode(control(), mem, adr, newval, adr_type, value_type->is_oopptr()));
       } else {
         assert(kind == LS_cmpxchg, "wrong LoadStore operation");
-        load_store = _gvn.transform(new (C) CompareAndSwapPNode(control(), mem, adr, newval, oldval));
+        load_store = _gvn.transform(new CompareAndSwapPNode(control(), mem, adr, newval, oldval));
       }
     }
     post_barrier(control(), load_store, base, adr, alias_idx, newval, T_OBJECT, true);
@@ -2988,13 +3027,13 @@
   // SCMemProjNodes represent the memory state of a LoadStore. Their
   // main role is to prevent LoadStore nodes from being optimized away
   // when their results aren't used.
-  Node* proj = _gvn.transform(new (C) SCMemProjNode(load_store));
+  Node* proj = _gvn.transform(new SCMemProjNode(load_store));
   set_memory(proj, alias_idx);
 
   if (type == T_OBJECT && kind == LS_xchg) {
 #ifdef _LP64
     if (adr->bottom_type()->is_ptr_to_narrowoop()) {
-      load_store = _gvn.transform(new (C) DecodeNNode(load_store, load_store->get_ptr_type()));
+      load_store = _gvn.transform(new DecodeNNode(load_store, load_store->get_ptr_type()));
     }
 #endif
     if (can_move_pre_barrier()) {
@@ -3136,7 +3175,7 @@
     // can generate code to load it as unsigned byte.
     Node* inst = make_load(NULL, insp, TypeInt::UBYTE, T_BOOLEAN, MemNode::unordered);
     Node* bits = intcon(InstanceKlass::fully_initialized);
-    test = _gvn.transform(new (C) SubINode(inst, bits));
+    test = _gvn.transform(new SubINode(inst, bits));
     // The 'test' is non-zero if we need to take a slow path.
   }
 
@@ -3160,9 +3199,9 @@
   Node* insp = basic_plus_adr(kls, in_bytes(offset));
   Node* tvalue = make_load(NULL, insp, TypeLong::LONG, T_LONG, MemNode::unordered);
   Node* bits = longcon(~0x03l); // ignore bit 0 & 1
-  Node* andl = _gvn.transform(new (C) AndLNode(tvalue, bits));
+  Node* andl = _gvn.transform(new AndLNode(tvalue, bits));
   Node* clsused = longcon(0x01l); // set the class bit
-  Node* orl = _gvn.transform(new (C) OrLNode(tvalue, clsused));
+  Node* orl = _gvn.transform(new OrLNode(tvalue, clsused));
 
   const TypePtr *adr_type = _gvn.type(insp)->isa_ptr();
   store_to_memory(control(), insp, orl, T_LONG, adr_type, MemNode::unordered);
@@ -3198,9 +3237,9 @@
   const TypeFunc* tf = OptoRuntime::void_long_Type();
   const TypePtr* no_memory_effects = NULL;
   Node* time = make_runtime_call(RC_LEAF, tf, funcAddr, funcName, no_memory_effects);
-  Node* value = _gvn.transform(new (C) ProjNode(time, TypeFunc::Parms+0));
+  Node* value = _gvn.transform(new ProjNode(time, TypeFunc::Parms+0));
 #ifdef ASSERT
-  Node* value_top = _gvn.transform(new (C) ProjNode(time, TypeFunc::Parms+1));
+  Node* value_top = _gvn.transform(new ProjNode(time, TypeFunc::Parms+1));
   assert(value_top == top(), "second value must be top");
 #endif
   set_result(value);
@@ -3241,18 +3280,18 @@
   // out of the function.
   insert_mem_bar(Op_MemBarCPUOrder);
 
-  RegionNode* result_rgn = new (C) RegionNode(PATH_LIMIT);
-  PhiNode*    result_val = new (C) PhiNode(result_rgn, TypeInt::BOOL);
-
-  RegionNode* slow_region = new (C) RegionNode(1);
+  RegionNode* result_rgn = new RegionNode(PATH_LIMIT);
+  PhiNode*    result_val = new PhiNode(result_rgn, TypeInt::BOOL);
+
+  RegionNode* slow_region = new RegionNode(1);
   record_for_igvn(slow_region);
 
   // (a) Receiving thread must be the current thread.
   Node* rec_thr = argument(0);
   Node* tls_ptr = NULL;
   Node* cur_thr = generate_current_thread(tls_ptr);
-  Node* cmp_thr = _gvn.transform(new (C) CmpPNode(cur_thr, rec_thr));
-  Node* bol_thr = _gvn.transform(new (C) BoolNode(cmp_thr, BoolTest::ne));
+  Node* cmp_thr = _gvn.transform(new CmpPNode(cur_thr, rec_thr));
+  Node* bol_thr = _gvn.transform(new BoolNode(cmp_thr, BoolTest::ne));
 
   generate_slow_guard(bol_thr, slow_region);
 
@@ -3263,33 +3302,33 @@
 
   // Set the control input on the field _interrupted read to prevent it floating up.
   Node* int_bit = make_load(control(), p, TypeInt::BOOL, T_INT, MemNode::unordered);
-  Node* cmp_bit = _gvn.transform(new (C) CmpINode(int_bit, intcon(0)));
-  Node* bol_bit = _gvn.transform(new (C) BoolNode(cmp_bit, BoolTest::ne));
+  Node* cmp_bit = _gvn.transform(new CmpINode(int_bit, intcon(0)));
+  Node* bol_bit = _gvn.transform(new BoolNode(cmp_bit, BoolTest::ne));
 
   IfNode* iff_bit = create_and_map_if(control(), bol_bit, PROB_UNLIKELY_MAG(3), COUNT_UNKNOWN);
 
   // First fast path:  if (!TLS._interrupted) return false;
-  Node* false_bit = _gvn.transform(new (C) IfFalseNode(iff_bit));
+  Node* false_bit = _gvn.transform(new IfFalseNode(iff_bit));
   result_rgn->init_req(no_int_result_path, false_bit);
   result_val->init_req(no_int_result_path, intcon(0));
 
   // drop through to next case
-  set_control( _gvn.transform(new (C) IfTrueNode(iff_bit)));
+  set_control( _gvn.transform(new IfTrueNode(iff_bit)));
 
 #ifndef TARGET_OS_FAMILY_windows
   // (c) Or, if interrupt bit is set and clear_int is false, use 2nd fast path.
   Node* clr_arg = argument(1);
-  Node* cmp_arg = _gvn.transform(new (C) CmpINode(clr_arg, intcon(0)));
-  Node* bol_arg = _gvn.transform(new (C) BoolNode(cmp_arg, BoolTest::ne));
+  Node* cmp_arg = _gvn.transform(new CmpINode(clr_arg, intcon(0)));
+  Node* bol_arg = _gvn.transform(new BoolNode(cmp_arg, BoolTest::ne));
   IfNode* iff_arg = create_and_map_if(control(), bol_arg, PROB_FAIR, COUNT_UNKNOWN);
 
   // Second fast path:  ... else if (!clear_int) return true;
-  Node* false_arg = _gvn.transform(new (C) IfFalseNode(iff_arg));
+  Node* false_arg = _gvn.transform(new IfFalseNode(iff_arg));
   result_rgn->init_req(no_clear_result_path, false_arg);
   result_val->init_req(no_clear_result_path, intcon(1));
 
   // drop through to next case
-  set_control( _gvn.transform(new (C) IfTrueNode(iff_arg)));
+  set_control( _gvn.transform(new IfTrueNode(iff_arg)));
 #else
   // To return true on Windows you must read the _interrupted field
   // and check the the event state i.e. take the slow path.
@@ -3375,9 +3414,9 @@
   Node* mods = make_load(NULL, modp, TypeInt::INT, T_INT, MemNode::unordered);
   Node* mask = intcon(modifier_mask);
   Node* bits = intcon(modifier_bits);
-  Node* mbit = _gvn.transform(new (C) AndINode(mods, mask));
-  Node* cmp  = _gvn.transform(new (C) CmpINode(mbit, bits));
-  Node* bol  = _gvn.transform(new (C) BoolNode(cmp, BoolTest::ne));
+  Node* mbit = _gvn.transform(new AndINode(mods, mask));
+  Node* cmp  = _gvn.transform(new CmpINode(mbit, bits));
+  Node* bol  = _gvn.transform(new BoolNode(cmp, BoolTest::ne));
   return generate_fair_guard(bol, region);
 }
 Node* LibraryCallKit::generate_interface_guard(Node* kls, RegionNode* region) {
@@ -3450,9 +3489,9 @@
 #endif
 
   // Null-check the mirror, and the mirror's klass ptr (in case it is a primitive).
-  RegionNode* region = new (C) RegionNode(PATH_LIMIT);
+  RegionNode* region = new RegionNode(PATH_LIMIT);
   record_for_igvn(region);
-  PhiNode* phi = new (C) PhiNode(region, return_type);
+  PhiNode* phi = new PhiNode(region, return_type);
 
   // The mirror will never be null of Reflection.getClassAccessFlags, however
   // it may be null for Class.isInstance or Class.getModifiers. Throw a NPE
@@ -3594,8 +3633,8 @@
     PATH_LIMIT
   };
 
-  RegionNode* region = new (C) RegionNode(PATH_LIMIT);
-  Node*       phi    = new (C) PhiNode(region, TypeInt::BOOL);
+  RegionNode* region = new RegionNode(PATH_LIMIT);
+  Node*       phi    = new PhiNode(region, TypeInt::BOOL);
   record_for_igvn(region);
 
   const TypePtr* adr_type = TypeRawPtr::BOTTOM;   // memory type of loads
@@ -3642,8 +3681,8 @@
   set_control(region->in(_prim_0_path)); // go back to first null check
   if (!stopped()) {
     // Since superc is primitive, make a guard for the superc==subc case.
-    Node* cmp_eq = _gvn.transform(new (C) CmpPNode(args[0], args[1]));
-    Node* bol_eq = _gvn.transform(new (C) BoolNode(cmp_eq, BoolTest::eq));
+    Node* cmp_eq = _gvn.transform(new CmpPNode(args[0], args[1]));
+    Node* bol_eq = _gvn.transform(new BoolNode(cmp_eq, BoolTest::eq));
     generate_guard(bol_eq, region, PROB_FAIR);
     if (region->req() == PATH_LIMIT+1) {
       // A guard was added.  If the added guard is taken, superc==subc.
@@ -3708,11 +3747,11 @@
                 ? ((jint)Klass::_lh_array_tag_type_value
                    <<    Klass::_lh_array_tag_shift)
                 : Klass::_lh_neutral_value);
-  Node* cmp = _gvn.transform(new(C) CmpINode(layout_val, intcon(nval)));
+  Node* cmp = _gvn.transform(new CmpINode(layout_val, intcon(nval)));
   BoolTest::mask btest = BoolTest::lt;  // correct for testing is_[obj]array
   // invert the test if we are looking for a non-array
   if (not_array)  btest = BoolTest(btest).negate();
-  Node* bol = _gvn.transform(new(C) BoolNode(cmp, btest));
+  Node* bol = _gvn.transform(new BoolNode(cmp, btest));
   return generate_fair_guard(bol, region);
 }
 
@@ -3728,12 +3767,10 @@
   if (stopped())  return true;
 
   enum { _normal_path = 1, _slow_path = 2, PATH_LIMIT };
-  RegionNode* result_reg = new(C) RegionNode(PATH_LIMIT);
-  PhiNode*    result_val = new(C) PhiNode(result_reg,
-                                          TypeInstPtr::NOTNULL);
-  PhiNode*    result_io  = new(C) PhiNode(result_reg, Type::ABIO);
-  PhiNode*    result_mem = new(C) PhiNode(result_reg, Type::MEMORY,
-                                          TypePtr::BOTTOM);
+  RegionNode* result_reg = new RegionNode(PATH_LIMIT);
+  PhiNode*    result_val = new PhiNode(result_reg, TypeInstPtr::NOTNULL);
+  PhiNode*    result_io  = new PhiNode(result_reg, Type::ABIO);
+  PhiNode*    result_mem = new PhiNode(result_reg, Type::MEMORY, TypePtr::BOTTOM);
 
   bool never_see_null = !too_many_traps(Deoptimization::Reason_null_check);
   Node* klass_node = load_array_klass_from_mirror(mirror, never_see_null,
@@ -3840,7 +3877,7 @@
     Node* klass_node = load_klass_from_mirror(array_type_mirror, false, NULL, 0);
     klass_node = null_check(klass_node);
 
-    RegionNode* bailout = new (C) RegionNode(1);
+    RegionNode* bailout = new RegionNode(1);
     record_for_igvn(bailout);
 
     // Despite the generic type of Arrays.copyOf, the mirror might be int, int[], etc.
@@ -3850,7 +3887,7 @@
       // Improve the klass node's type from the new optimistic assumption:
       ciKlass* ak = ciArrayKlass::make(env()->Object_klass());
       const Type* akls = TypeKlassPtr::make(TypePtr::NotNull, ak, 0/*offset*/);
-      Node* cast = new (C) CastPPNode(klass_node, akls);
+      Node* cast = new CastPPNode(klass_node, akls);
       cast->init_req(0, control());
       klass_node = _gvn.transform(cast);
     }
@@ -3861,7 +3898,7 @@
 
     Node* length = end;
     if (_gvn.type(start) != TypeInt::ZERO) {
-      length = _gvn.transform(new (C) SubINode(end, start));
+      length = _gvn.transform(new SubINode(end, start));
     }
 
     // Bail out if length is negative.
@@ -3880,7 +3917,7 @@
     if (!stopped()) {
       // How many elements will we copy from the original?
       // The answer is MinI(orig_length - start, length).
-      Node* orig_tail = _gvn.transform(new (C) SubINode(orig_length, start));
+      Node* orig_tail = _gvn.transform(new SubINode(orig_length, start));
       Node* moved = generate_min_max(vmIntrinsics::_min, orig_tail, length);
 
       newcopy = new_array(klass_node, length, 0);  // no argments to push
@@ -3927,8 +3964,8 @@
   const TypePtr* native_call_addr = TypeMetadataPtr::make(method);
 
   Node* native_call = makecon(native_call_addr);
-  Node* chk_native  = _gvn.transform(new(C) CmpPNode(target_call, native_call));
-  Node* test_native = _gvn.transform(new(C) BoolNode(chk_native, BoolTest::ne));
+  Node* chk_native  = _gvn.transform(new CmpPNode(target_call, native_call));
+  Node* test_native = _gvn.transform(new BoolNode(chk_native, BoolTest::ne));
 
   return generate_slow_guard(test_native, slow_region);
 }
@@ -3953,7 +3990,7 @@
   CallJavaNode* slow_call;
   if (is_static) {
     assert(!is_virtual, "");
-    slow_call = new(C) CallStaticJavaNode(C, tf,
+    slow_call = new CallStaticJavaNode(C, tf,
                            SharedRuntime::get_resolve_static_call_stub(),
                            method, bci());
   } else if (is_virtual) {
@@ -3969,12 +4006,12 @@
        assert(vtable_index >= 0 || vtable_index == Method::nonvirtual_vtable_index,
               err_msg_res("bad index %d", vtable_index));
     }
-    slow_call = new(C) CallDynamicJavaNode(tf,
+    slow_call = new CallDynamicJavaNode(tf,
                           SharedRuntime::get_resolve_virtual_call_stub(),
                           method, vtable_index, bci());
   } else {  // neither virtual nor static:  opt_virtual
     null_check_receiver();
-    slow_call = new(C) CallStaticJavaNode(C, tf,
+    slow_call = new CallStaticJavaNode(C, tf,
                                 SharedRuntime::get_resolve_opt_virtual_call_stub(),
                                 method, bci());
     slow_call->set_optimized_virtual(true);
@@ -3985,20 +4022,21 @@
 }
 
 
-//------------------------------inline_native_hashcode--------------------
-// Build special case code for calls to hashCode on an object.
+/**
+ * Build special case code for calls to hashCode on an object. This call may
+ * be virtual (invokevirtual) or bound (invokespecial). For each case we generate
+ * slightly different code.
+ */
 bool LibraryCallKit::inline_native_hashcode(bool is_virtual, bool is_static) {
   assert(is_static == callee()->is_static(), "correct intrinsic selection");
   assert(!(is_virtual && is_static), "either virtual, special, or static");
 
   enum { _slow_path = 1, _fast_path, _null_path, PATH_LIMIT };
 
-  RegionNode* result_reg = new(C) RegionNode(PATH_LIMIT);
-  PhiNode*    result_val = new(C) PhiNode(result_reg,
-                                          TypeInt::INT);
-  PhiNode*    result_io  = new(C) PhiNode(result_reg, Type::ABIO);
-  PhiNode*    result_mem = new(C) PhiNode(result_reg, Type::MEMORY,
-                                          TypePtr::BOTTOM);
+  RegionNode* result_reg = new RegionNode(PATH_LIMIT);
+  PhiNode*    result_val = new PhiNode(result_reg, TypeInt::INT);
+  PhiNode*    result_io  = new PhiNode(result_reg, Type::ABIO);
+  PhiNode*    result_mem = new PhiNode(result_reg, Type::MEMORY, TypePtr::BOTTOM);
   Node* obj = NULL;
   if (!is_static) {
     // Check for hashing null object
@@ -4024,15 +4062,9 @@
     return true;
   }
 
-  // After null check, get the object's klass.
-  Node* obj_klass = load_object_klass(obj);
-
-  // This call may be virtual (invokevirtual) or bound (invokespecial).
-  // For each case we generate slightly different code.
-
   // We only go to the fast case code if we pass a number of guards.  The
   // paths which do not pass are accumulated in the slow_region.
-  RegionNode* slow_region = new (C) RegionNode(1);
+  RegionNode* slow_region = new RegionNode(1);
   record_for_igvn(slow_region);
 
   // If this is a virtual call, we generate a funny guard.  We pull out
@@ -4042,19 +4074,24 @@
   // guard for non-virtual calls -- the caller is known to be the native
   // Object hashCode().
   if (is_virtual) {
+    // After null check, get the object's klass.
+    Node* obj_klass = load_object_klass(obj);
     generate_virtual_guard(obj_klass, slow_region);
   }
 
   // Get the header out of the object, use LoadMarkNode when available
   Node* header_addr = basic_plus_adr(obj, oopDesc::mark_offset_in_bytes());
-  Node* header = make_load(control(), header_addr, TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
+  // The control of the load must be NULL. Otherwise, the load can move before
+  // the null check after castPP removal.
+  Node* no_ctrl = NULL;
+  Node* header = make_load(no_ctrl, header_addr, TypeX_X, TypeX_X->basic_type(), MemNode::unordered);
 
   // Test the header to see if it is unlocked.
   Node *lock_mask      = _gvn.MakeConX(markOopDesc::biased_lock_mask_in_place);
-  Node *lmasked_header = _gvn.transform(new (C) AndXNode(header, lock_mask));
+  Node *lmasked_header = _gvn.transform(new AndXNode(header, lock_mask));
   Node *unlocked_val   = _gvn.MakeConX(markOopDesc::unlocked_value);
-  Node *chk_unlocked   = _gvn.transform(new (C) CmpXNode( lmasked_header, unlocked_val));
-  Node *test_unlocked  = _gvn.transform(new (C) BoolNode( chk_unlocked, BoolTest::ne));
+  Node *chk_unlocked   = _gvn.transform(new CmpXNode( lmasked_header, unlocked_val));
+  Node *test_unlocked  = _gvn.transform(new BoolNode( chk_unlocked, BoolTest::ne));
 
   generate_slow_guard(test_unlocked, slow_region);
 
@@ -4064,17 +4101,17 @@
   // vm: see markOop.hpp.
   Node *hash_mask      = _gvn.intcon(markOopDesc::hash_mask);
   Node *hash_shift     = _gvn.intcon(markOopDesc::hash_shift);
-  Node *hshifted_header= _gvn.transform(new (C) URShiftXNode(header, hash_shift));
+  Node *hshifted_header= _gvn.transform(new URShiftXNode(header, hash_shift));
   // This hack lets the hash bits live anywhere in the mark object now, as long
   // as the shift drops the relevant bits into the low 32 bits.  Note that
   // Java spec says that HashCode is an int so there's no point in capturing
   // an 'X'-sized hashcode (32 in 32-bit build or 64 in 64-bit build).
   hshifted_header      = ConvX2I(hshifted_header);
-  Node *hash_val       = _gvn.transform(new (C) AndINode(hshifted_header, hash_mask));
+  Node *hash_val       = _gvn.transform(new AndINode(hshifted_header, hash_mask));
 
   Node *no_hash_val    = _gvn.intcon(markOopDesc::no_hash);
-  Node *chk_assigned   = _gvn.transform(new (C) CmpINode( hash_val, no_hash_val));
-  Node *test_assigned  = _gvn.transform(new (C) BoolNode( chk_assigned, BoolTest::eq));
+  Node *chk_assigned   = _gvn.transform(new CmpINode( hash_val, no_hash_val));
+  Node *test_assigned  = _gvn.transform(new BoolNode( chk_assigned, BoolTest::eq));
 
   generate_slow_guard(test_assigned, slow_region);
 
@@ -4213,19 +4250,19 @@
   Node* result;
 
   switch (id) {
-  case vmIntrinsics::_floatToRawIntBits:    result = new (C) MoveF2INode(arg);  break;
-  case vmIntrinsics::_intBitsToFloat:       result = new (C) MoveI2FNode(arg);  break;
-  case vmIntrinsics::_doubleToRawLongBits:  result = new (C) MoveD2LNode(arg);  break;
-  case vmIntrinsics::_longBitsToDouble:     result = new (C) MoveL2DNode(arg);  break;
+  case vmIntrinsics::_floatToRawIntBits:    result = new MoveF2INode(arg);  break;
+  case vmIntrinsics::_intBitsToFloat:       result = new MoveI2FNode(arg);  break;
+  case vmIntrinsics::_doubleToRawLongBits:  result = new MoveD2LNode(arg);  break;
+  case vmIntrinsics::_longBitsToDouble:     result = new MoveL2DNode(arg);  break;
 
   case vmIntrinsics::_doubleToLongBits: {
     // two paths (plus control) merge in a wood
-    RegionNode *r = new (C) RegionNode(3);
-    Node *phi = new (C) PhiNode(r, TypeLong::LONG);
-
-    Node *cmpisnan = _gvn.transform(new (C) CmpDNode(arg, arg));
+    RegionNode *r = new RegionNode(3);
+    Node *phi = new PhiNode(r, TypeLong::LONG);
+
+    Node *cmpisnan = _gvn.transform(new CmpDNode(arg, arg));
     // Build the boolean node
-    Node *bolisnan = _gvn.transform(new (C) BoolNode(cmpisnan, BoolTest::ne));
+    Node *bolisnan = _gvn.transform(new BoolNode(cmpisnan, BoolTest::ne));
 
     // Branch either way.
     // NaN case is less traveled, which makes all the difference.
@@ -4233,7 +4270,7 @@
     Node *opt_isnan = _gvn.transform(ifisnan);
     assert( opt_isnan->is_If(), "Expect an IfNode");
     IfNode *opt_ifisnan = (IfNode*)opt_isnan;
-    Node *iftrue = _gvn.transform(new (C) IfTrueNode(opt_ifisnan));
+    Node *iftrue = _gvn.transform(new IfTrueNode(opt_ifisnan));
 
     set_control(iftrue);
 
@@ -4243,10 +4280,10 @@
     r->init_req(1, iftrue);
 
     // Else fall through
-    Node *iffalse = _gvn.transform(new (C) IfFalseNode(opt_ifisnan));
+    Node *iffalse = _gvn.transform(new IfFalseNode(opt_ifisnan));
     set_control(iffalse);
 
-    phi->init_req(2, _gvn.transform(new (C) MoveD2LNode(arg)));
+    phi->init_req(2, _gvn.transform(new MoveD2LNode(arg)));
     r->init_req(2, iffalse);
 
     // Post merge
@@ -4261,12 +4298,12 @@
 
   case vmIntrinsics::_floatToIntBits: {
     // two paths (plus control) merge in a wood
-    RegionNode *r = new (C) RegionNode(3);
-    Node *phi = new (C) PhiNode(r, TypeInt::INT);
-
-    Node *cmpisnan = _gvn.transform(new (C) CmpFNode(arg, arg));
+    RegionNode *r = new RegionNode(3);
+    Node *phi = new PhiNode(r, TypeInt::INT);
+
+    Node *cmpisnan = _gvn.transform(new CmpFNode(arg, arg));
     // Build the boolean node
-    Node *bolisnan = _gvn.transform(new (C) BoolNode(cmpisnan, BoolTest::ne));
+    Node *bolisnan = _gvn.transform(new BoolNode(cmpisnan, BoolTest::ne));
 
     // Branch either way.
     // NaN case is less traveled, which makes all the difference.
@@ -4274,7 +4311,7 @@
     Node *opt_isnan = _gvn.transform(ifisnan);
     assert( opt_isnan->is_If(), "Expect an IfNode");
     IfNode *opt_ifisnan = (IfNode*)opt_isnan;
-    Node *iftrue = _gvn.transform(new (C) IfTrueNode(opt_ifisnan));
+    Node *iftrue = _gvn.transform(new IfTrueNode(opt_ifisnan));
 
     set_control(iftrue);
 
@@ -4284,10 +4321,10 @@
     r->init_req(1, iftrue);
 
     // Else fall through
-    Node *iffalse = _gvn.transform(new (C) IfFalseNode(opt_ifisnan));
+    Node *iffalse = _gvn.transform(new IfFalseNode(opt_ifisnan));
     set_control(iffalse);
 
-    phi->init_req(2, _gvn.transform(new (C) MoveF2INode(arg)));
+    phi->init_req(2, _gvn.transform(new MoveF2INode(arg)));
     r->init_req(2, iffalse);
 
     // Post merge
@@ -4403,8 +4440,8 @@
 
   // Compute the length also, if needed:
   Node* countx = size;
-  countx = _gvn.transform(new (C) SubXNode(countx, MakeConX(base_off)));
-  countx = _gvn.transform(new (C) URShiftXNode(countx, intcon(LogBytesPerLong) ));
+  countx = _gvn.transform(new SubXNode(countx, MakeConX(base_off)));
+  countx = _gvn.transform(new URShiftXNode(countx, intcon(LogBytesPerLong) ));
 
   const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
   bool disjoint_bases = true;
@@ -4493,12 +4530,10 @@
       _instance_path,     // plain instance allocation, plus arrayof_long_arraycopy
       PATH_LIMIT
     };
-    RegionNode* result_reg = new(C) RegionNode(PATH_LIMIT);
-    result_val             = new(C) PhiNode(result_reg,
-                                            TypeInstPtr::NOTNULL);
-    PhiNode*    result_i_o = new(C) PhiNode(result_reg, Type::ABIO);
-    PhiNode*    result_mem = new(C) PhiNode(result_reg, Type::MEMORY,
-                                            TypePtr::BOTTOM);
+    RegionNode* result_reg = new RegionNode(PATH_LIMIT);
+    result_val             = new PhiNode(result_reg, TypeInstPtr::NOTNULL);
+    PhiNode*    result_i_o = new PhiNode(result_reg, Type::ABIO);
+    PhiNode*    result_mem = new PhiNode(result_reg, Type::MEMORY, TypePtr::BOTTOM);
     record_for_igvn(result_reg);
 
     const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
@@ -4554,7 +4589,7 @@
 
     // We only go to the instance fast case code if we pass a number of guards.
     // The paths which do not pass are accumulated in the slow_region.
-    RegionNode* slow_region = new (C) RegionNode(1);
+    RegionNode* slow_region = new RegionNode(1);
     record_for_igvn(slow_region);
     if (!stopped()) {
       // It's an instance (we did array above).  Make the slow-path tests.
@@ -4583,7 +4618,10 @@
       // It's an instance, and it passed the slow-path tests.
       PreserveJVMState pjvms(this);
       Node* obj_size  = NULL;
-      Node* alloc_obj = new_instance(obj_klass, NULL, &obj_size);
+      // Need to deoptimize on exception from allocation since Object.clone intrinsic
+      // is reexecuted if deoptimization occurs and there could be problems when merging
+      // exception state between multiple Object.clone versions (reexecute=true vs reexecute=false).
+      Node* alloc_obj = new_instance(obj_klass, NULL, &obj_size, /*deoptimize_on_exception=*/true);
 
       copy_to_clone(obj, alloc_obj, obj_size, false, !use_ReduceInitialCardMarks());
 
@@ -4811,7 +4849,7 @@
   // (8) dest_offset + length must not exceed length of dest.
   // (9) each element of an oop array must be assignable
 
-  RegionNode* slow_region = new (C) RegionNode(1);
+  RegionNode* slow_region = new RegionNode(1);
   record_for_igvn(slow_region);
 
   // (3) operands must not be null
@@ -4899,7 +4937,7 @@
                                    RegionNode* slow_region) {
 
   if (slow_region == NULL) {
-    slow_region = new(C) RegionNode(1);
+    slow_region = new RegionNode(1);
     record_for_igvn(slow_region);
   }
 
@@ -4947,9 +4985,9 @@
          bcopy_path       = 5,  // copy primitive array by 64-bit blocks
          PATH_LIMIT       = 6
   };
-  RegionNode* result_region = new(C) RegionNode(PATH_LIMIT);
-  PhiNode*    result_i_o    = new(C) PhiNode(result_region, Type::ABIO);
-  PhiNode*    result_memory = new(C) PhiNode(result_region, Type::MEMORY, adr_type);
+  RegionNode* result_region = new RegionNode(PATH_LIMIT);
+  PhiNode*    result_i_o    = new PhiNode(result_region, Type::ABIO);
+  PhiNode*    result_memory = new PhiNode(result_region, Type::MEMORY, adr_type);
   record_for_igvn(result_region);
   _gvn.set_type_bottom(result_i_o);
   _gvn.set_type_bottom(result_memory);
@@ -5023,8 +5061,7 @@
     // are dest_head = dest[0..off] and dest_tail = dest[off+len..dest.length].
     Node* dest_size   = alloc->in(AllocateNode::AllocSize);
     Node* dest_length = alloc->in(AllocateNode::ALength);
-    Node* dest_tail   = _gvn.transform(new(C) AddINode(dest_offset,
-                                                          copy_length));
+    Node* dest_tail   = _gvn.transform(new AddINode(dest_offset, copy_length));
 
     // If there is a head section that needs zeroing, do it now.
     if (find_int_con(dest_offset, -1) != 0) {
@@ -5040,8 +5077,8 @@
     // the copy to a more hardware-friendly word size of 64 bits.
     Node* tail_ctl = NULL;
     if (!stopped() && !dest_tail->eqv_uncast(dest_length)) {
-      Node* cmp_lt   = _gvn.transform(new(C) CmpINode(dest_tail, dest_length));
-      Node* bol_lt   = _gvn.transform(new(C) BoolNode(cmp_lt, BoolTest::lt));
+      Node* cmp_lt   = _gvn.transform(new CmpINode(dest_tail, dest_length));
+      Node* bol_lt   = _gvn.transform(new BoolNode(cmp_lt, BoolTest::lt));
       tail_ctl = generate_slow_guard(bol_lt, NULL);
       assert(tail_ctl != NULL || !stopped(), "must be an outcome");
     }
@@ -5075,8 +5112,8 @@
                              dest_size);
       } else {
         // Make a local merge.
-        Node* done_ctl = new(C) RegionNode(3);
-        Node* done_mem = new(C) PhiNode(done_ctl, Type::MEMORY, adr_type);
+        Node* done_ctl = new RegionNode(3);
+        Node* done_mem = new PhiNode(done_ctl, Type::MEMORY, adr_type);
         done_ctl->init_req(1, notail_ctl);
         done_mem->init_req(1, memory(adr_type));
         generate_clear_array(adr_type, dest, basic_elem_type,
@@ -5171,21 +5208,21 @@
     // Clean up after the checked call.
     // The returned value is either 0 or -1^K,
     // where K = number of partially transferred array elements.
-    Node* cmp = _gvn.transform(new(C) CmpINode(checked_value, intcon(0)));
-    Node* bol = _gvn.transform(new(C) BoolNode(cmp, BoolTest::eq));
+    Node* cmp = _gvn.transform(new CmpINode(checked_value, intcon(0)));
+    Node* bol = _gvn.transform(new BoolNode(cmp, BoolTest::eq));
     IfNode* iff = create_and_map_if(control(), bol, PROB_MAX, COUNT_UNKNOWN);
 
     // If it is 0, we are done, so transfer to the end.
-    Node* checks_done = _gvn.transform(new(C) IfTrueNode(iff));
+    Node* checks_done = _gvn.transform(new IfTrueNode(iff));
     result_region->init_req(checked_path, checks_done);
     result_i_o   ->init_req(checked_path, checked_i_o);
     result_memory->init_req(checked_path, checked_mem);
 
     // If it is not zero, merge into the slow call.
-    set_control( _gvn.transform(new(C) IfFalseNode(iff) ));
-    RegionNode* slow_reg2 = new(C) RegionNode(3);
-    PhiNode*    slow_i_o2 = new(C) PhiNode(slow_reg2, Type::ABIO);
-    PhiNode*    slow_mem2 = new(C) PhiNode(slow_reg2, Type::MEMORY, adr_type);
+    set_control( _gvn.transform(new IfFalseNode(iff) ));
+    RegionNode* slow_reg2 = new RegionNode(3);
+    PhiNode*    slow_i_o2 = new PhiNode(slow_reg2, Type::ABIO);
+    PhiNode*    slow_mem2 = new PhiNode(slow_reg2, Type::MEMORY, adr_type);
     record_for_igvn(slow_reg2);
     slow_reg2  ->init_req(1, slow_control);
     slow_i_o2  ->init_req(1, slow_i_o);
@@ -5205,16 +5242,16 @@
     } else {
       // We must continue the copy exactly where it failed, or else
       // another thread might see the wrong number of writes to dest.
-      Node* checked_offset = _gvn.transform(new(C) XorINode(checked_value, intcon(-1)));
-      Node* slow_offset    = new(C) PhiNode(slow_reg2, TypeInt::INT);
+      Node* checked_offset = _gvn.transform(new XorINode(checked_value, intcon(-1)));
+      Node* slow_offset    = new PhiNode(slow_reg2, TypeInt::INT);
       slow_offset->init_req(1, intcon(0));
       slow_offset->init_req(2, checked_offset);
       slow_offset  = _gvn.transform(slow_offset);
 
       // Adjust the arguments by the conditionally incoming offset.
-      Node* src_off_plus  = _gvn.transform(new(C) AddINode(src_offset,  slow_offset));
-      Node* dest_off_plus = _gvn.transform(new(C) AddINode(dest_offset, slow_offset));
-      Node* length_minus  = _gvn.transform(new(C) SubINode(copy_length, slow_offset));
+      Node* src_off_plus  = _gvn.transform(new AddINode(src_offset,  slow_offset));
+      Node* dest_off_plus = _gvn.transform(new AddINode(dest_offset, slow_offset));
+      Node* length_minus  = _gvn.transform(new SubINode(copy_length, slow_offset));
 
       // Tweak the node variables to adjust the code produced below:
       src_offset  = src_off_plus;
@@ -5435,10 +5472,10 @@
     int      end_round = (-1 << scale) & (BytesPerLong  - 1);
     Node*    end       = ConvI2X(slice_len);
     if (scale != 0)
-      end = _gvn.transform(new(C) LShiftXNode(end, intcon(scale) ));
+      end = _gvn.transform(new LShiftXNode(end, intcon(scale) ));
     end_base += end_round;
-    end = _gvn.transform(new(C) AddXNode(end, MakeConX(end_base)));
-    end = _gvn.transform(new(C) AndXNode(end, MakeConX(~end_round)));
+    end = _gvn.transform(new AddXNode(end, MakeConX(end_base)));
+    end = _gvn.transform(new AndXNode(end, MakeConX(~end_round)));
     mem = ClearArrayNode::clear_memory(control(), mem, dest,
                                        start_con, end, &_gvn);
   } else if (start_con < 0 && dest_size != top()) {
@@ -5447,8 +5484,8 @@
     Node* start = slice_idx;
     start = ConvI2X(start);
     if (scale != 0)
-      start = _gvn.transform(new(C) LShiftXNode( start, intcon(scale) ));
-    start = _gvn.transform(new(C) AddXNode(start, MakeConX(abase)));
+      start = _gvn.transform(new LShiftXNode( start, intcon(scale) ));
+    start = _gvn.transform(new AddXNode(start, MakeConX(abase)));
     if ((bump_bit | clear_low) != 0) {
       int to_clear = (bump_bit | clear_low);
       // Align up mod 8, then store a jint zero unconditionally
@@ -5459,14 +5496,14 @@
         assert((abase & to_clear) == 0, "array base must be long-aligned");
       } else {
         // Bump 'start' up to (or past) the next jint boundary:
-        start = _gvn.transform(new(C) AddXNode(start, MakeConX(bump_bit)));
+        start = _gvn.transform(new AddXNode(start, MakeConX(bump_bit)));
         assert((abase & clear_low) == 0, "array base must be int-aligned");
       }
       // Round bumped 'start' down to jlong boundary in body of array.
-      start = _gvn.transform(new(C) AndXNode(start, MakeConX(~to_clear)));
+      start = _gvn.transform(new AndXNode(start, MakeConX(~to_clear)));
       if (bump_bit != 0) {
         // Store a zero to the immediately preceding jint:
-        Node* x1 = _gvn.transform(new(C) AddXNode(start, MakeConX(-bump_bit)));
+        Node* x1 = _gvn.transform(new AddXNode(start, MakeConX(-bump_bit)));
         Node* p1 = basic_plus_adr(dest, x1);
         mem = StoreNode::make(_gvn, control(), mem, p1, adr_type, intcon(0), T_INT, MemNode::unordered);
         mem = _gvn.transform(mem);
@@ -5533,8 +5570,8 @@
   Node* sptr  = basic_plus_adr(src,  src_off);
   Node* dptr  = basic_plus_adr(dest, dest_off);
   Node* countx = dest_size;
-  countx = _gvn.transform(new (C) SubXNode(countx, MakeConX(dest_off)));
-  countx = _gvn.transform(new (C) URShiftXNode(countx, intcon(LogBytesPerLong)));
+  countx = _gvn.transform(new SubXNode(countx, MakeConX(dest_off)));
+  countx = _gvn.transform(new URShiftXNode(countx, intcon(LogBytesPerLong)));
 
   bool disjoint_bases = true;   // since alloc != NULL
   generate_unchecked_arraycopy(adr_type, T_LONG, disjoint_bases,
@@ -5584,7 +5621,7 @@
   // super_check_offset, for the desired klass.
   int sco_offset = in_bytes(Klass::super_check_offset_offset());
   Node* p3 = basic_plus_adr(dest_elem_klass, sco_offset);
-  Node* n3 = new(C) LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr(), TypeInt::INT, MemNode::unordered);
+  Node* n3 = new LoadINode(NULL, memory(p3), p3, _gvn.type(p3)->is_ptr(), TypeInt::INT, MemNode::unordered);
   Node* check_offset = ConvI2X(_gvn.transform(n3));
   Node* check_value  = dest_elem_klass;
 
@@ -5602,7 +5639,7 @@
                                  check_offset XTOP,
                                  check_value);
 
-  return _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+  return _gvn.transform(new ProjNode(call, TypeFunc::Parms));
 }
 
 
@@ -5624,7 +5661,7 @@
                     copyfunc_addr, "generic_arraycopy", adr_type,
                     src, src_offset, dest, dest_offset, copy_length);
 
-  return _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+  return _gvn.transform(new ProjNode(call, TypeFunc::Parms));
 }
 
 // Helper function; generates the fast out-of-line call to an arraycopy stub.
@@ -5691,9 +5728,9 @@
   // 'dst_start' points to dst array + scaled offset
 
   const TypeAryPtr* mtype = TypeAryPtr::BYTES;
-  Node* enc = new (C) EncodeISOArrayNode(control(), memory(mtype), src_start, dst_start, length);
+  Node* enc = new EncodeISOArrayNode(control(), memory(mtype), src_start, dst_start, length);
   enc = _gvn.transform(enc);
-  Node* res_mem = _gvn.transform(new (C) SCMemProjNode(enc));
+  Node* res_mem = _gvn.transform(new SCMemProjNode(enc));
   set_memory(res_mem, mtype);
   set_result(enc);
   return true;
@@ -5718,18 +5755,18 @@
    */
 
   Node* M1 = intcon(-1);
-  crc = _gvn.transform(new (C) XorINode(crc, M1));
-  Node* result = _gvn.transform(new (C) XorINode(crc, b));
-  result = _gvn.transform(new (C) AndINode(result, intcon(0xFF)));
+  crc = _gvn.transform(new XorINode(crc, M1));
+  Node* result = _gvn.transform(new XorINode(crc, b));
+  result = _gvn.transform(new AndINode(result, intcon(0xFF)));
 
   Node* base = makecon(TypeRawPtr::make(StubRoutines::crc_table_addr()));
-  Node* offset = _gvn.transform(new (C) LShiftINode(result, intcon(0x2)));
+  Node* offset = _gvn.transform(new LShiftINode(result, intcon(0x2)));
   Node* adr = basic_plus_adr(top(), base, ConvI2X(offset));
   result = make_load(control(), adr, TypeInt::INT, T_INT, MemNode::unordered);
 
-  crc = _gvn.transform(new (C) URShiftINode(crc, intcon(8)));
-  result = _gvn.transform(new (C) XorINode(crc, result));
-  result = _gvn.transform(new (C) XorINode(result, M1));
+  crc = _gvn.transform(new URShiftINode(crc, intcon(8)));
+  result = _gvn.transform(new XorINode(crc, result));
+  result = _gvn.transform(new XorINode(result, M1));
   set_result(result);
   return true;
 }
@@ -5773,7 +5810,7 @@
   Node* call = make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::updateBytesCRC32_Type(),
                                  stubAddr, stubName, TypePtr::BOTTOM,
                                  crc, src_start, length);
-  Node* result = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+  Node* result = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
   set_result(result);
   return true;
 }
@@ -5792,7 +5829,7 @@
   Node* length  = argument(4); // type: int
 
   src = ConvL2X(src);  // adjust Java long to machine word
-  Node* base = _gvn.transform(new (C) CastX2PNode(src));
+  Node* base = _gvn.transform(new CastX2PNode(src));
   offset = ConvI2X(offset);
 
   // 'src_start' points to src array + scaled offset
@@ -5805,7 +5842,7 @@
   Node* call = make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::updateBytesCRC32_Type(),
                                  stubAddr, stubName, TypePtr::BOTTOM,
                                  crc, src_start, length);
-  Node* result = _gvn.transform(new (C) ProjNode(call, TypeFunc::Parms));
+  Node* result = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
   set_result(result);
   return true;
 }
@@ -5870,7 +5907,12 @@
   BasicType bt = field->layout_type();
 
   // Build the resultant type of the load
-  const Type *type = TypeOopPtr::make_from_klass(field_klass->as_klass());
+  const Type *type;
+  if (bt == T_OBJECT) {
+    type = TypeOopPtr::make_from_klass(field_klass->as_klass());
+  } else {
+    type = Type::get_const_basic_type(bt);
+  }
 
   // Build the load.
   Node* loadedField = make_load(NULL, adr, type, bt, adr_type, MemNode::unordered, is_vol);
@@ -6000,12 +6042,12 @@
   assert(tinst != NULL, "CBC obj is null");
   assert(tinst->klass()->is_loaded(), "CBC obj is not loaded");
   ciKlass* klass_AESCrypt = tinst->klass()->as_instance_klass()->find_klass(ciSymbol::make("com/sun/crypto/provider/AESCrypt"));
-  if (!klass_AESCrypt->is_loaded()) return false;
+  assert(klass_AESCrypt->is_loaded(), "predicate checks that this class is loaded");
 
   ciInstanceKlass* instklass_AESCrypt = klass_AESCrypt->as_instance_klass();
   const TypeKlassPtr* aklass = TypeKlassPtr::make(instklass_AESCrypt);
   const TypeOopPtr* xtype = aklass->as_instance_type();
-  Node* aescrypt_object = new(C) CheckCastPPNode(control(), embeddedCipherObj, xtype);
+  Node* aescrypt_object = new CheckCastPPNode(control(), embeddedCipherObj, xtype);
   aescrypt_object = _gvn.transform(aescrypt_object);
 
   // we need to get the start of the aescrypt_object's expanded key array
@@ -6038,7 +6080,7 @@
   }
 
   // return cipher length (int)
-  Node* retvalue = _gvn.transform(new (C) ProjNode(cbcCrypt, TypeFunc::Parms));
+  Node* retvalue = _gvn.transform(new ProjNode(cbcCrypt, TypeFunc::Parms));
   set_result(retvalue);
   return true;
 }
@@ -6075,11 +6117,8 @@
 //    note cipher==plain is more conservative than the original java code but that's OK
 //
 Node* LibraryCallKit::inline_cipherBlockChaining_AESCrypt_predicate(bool decrypting) {
-  // First, check receiver for NULL since it is virtual method.
+  // The receiver was checked for NULL already.
   Node* objCBC = argument(0);
-  objCBC = null_check(objCBC);
-
-  if (stopped()) return NULL; // Always NULL
 
   // Load embeddedCipher field of CipherBlockChaining object.
   Node* embeddedCipherObj = load_field_from_object(objCBC, "embeddedCipher", "Lcom/sun/crypto/provider/SymmetricCipher;", /*is_exact*/ false);
@@ -6102,8 +6141,8 @@
   ciInstanceKlass* instklass_AESCrypt = klass_AESCrypt->as_instance_klass();
 
   Node* instof = gen_instanceof(embeddedCipherObj, makecon(TypeKlassPtr::make(instklass_AESCrypt)));
-  Node* cmp_instof  = _gvn.transform(new (C) CmpINode(instof, intcon(1)));
-  Node* bool_instof  = _gvn.transform(new (C) BoolNode(cmp_instof, BoolTest::ne));
+  Node* cmp_instof  = _gvn.transform(new CmpINode(instof, intcon(1)));
+  Node* bool_instof  = _gvn.transform(new BoolNode(cmp_instof, BoolTest::ne));
 
   Node* instof_false = generate_guard(bool_instof, NULL, PROB_MIN);
 
@@ -6114,15 +6153,270 @@
   // for decryption, we need to add a further check to avoid
   // taking the intrinsic path when cipher and plain are the same
   // see the original java code for why.
-  RegionNode* region = new(C) RegionNode(3);
+  RegionNode* region = new RegionNode(3);
   region->init_req(1, instof_false);
   Node* src = argument(1);
   Node* dest = argument(4);
-  Node* cmp_src_dest = _gvn.transform(new (C) CmpPNode(src, dest));
-  Node* bool_src_dest = _gvn.transform(new (C) BoolNode(cmp_src_dest, BoolTest::eq));
+  Node* cmp_src_dest = _gvn.transform(new CmpPNode(src, dest));
+  Node* bool_src_dest = _gvn.transform(new BoolNode(cmp_src_dest, BoolTest::eq));
   Node* src_dest_conjoint = generate_guard(bool_src_dest, NULL, PROB_MIN);
   region->init_req(2, src_dest_conjoint);
 
   record_for_igvn(region);
   return _gvn.transform(region);
 }
+
+//------------------------------inline_sha_implCompress-----------------------
+//
+// Calculate SHA (i.e., SHA-1) for single-block byte[] array.
+// void com.sun.security.provider.SHA.implCompress(byte[] buf, int ofs)
+//
+// Calculate SHA2 (i.e., SHA-244 or SHA-256) for single-block byte[] array.
+// void com.sun.security.provider.SHA2.implCompress(byte[] buf, int ofs)
+//
+// Calculate SHA5 (i.e., SHA-384 or SHA-512) for single-block byte[] array.
+// void com.sun.security.provider.SHA5.implCompress(byte[] buf, int ofs)
+//
+bool LibraryCallKit::inline_sha_implCompress(vmIntrinsics::ID id) {
+  assert(callee()->signature()->size() == 2, "sha_implCompress has 2 parameters");
+
+  Node* sha_obj = argument(0);
+  Node* src     = argument(1); // type oop
+  Node* ofs     = argument(2); // type int
+
+  const Type* src_type = src->Value(&_gvn);
+  const TypeAryPtr* top_src = src_type->isa_aryptr();
+  if (top_src  == NULL || top_src->klass()  == NULL) {
+    // failed array check
+    return false;
+  }
+  // Figure out the size and type of the elements we will be copying.
+  BasicType src_elem = src_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+  if (src_elem != T_BYTE) {
+    return false;
+  }
+  // 'src_start' points to src array + offset
+  Node* src_start = array_element_address(src, ofs, src_elem);
+  Node* state = NULL;
+  address stubAddr;
+  const char *stubName;
+
+  switch(id) {
+  case vmIntrinsics::_sha_implCompress:
+    assert(UseSHA1Intrinsics, "need SHA1 instruction support");
+    state = get_state_from_sha_object(sha_obj);
+    stubAddr = StubRoutines::sha1_implCompress();
+    stubName = "sha1_implCompress";
+    break;
+  case vmIntrinsics::_sha2_implCompress:
+    assert(UseSHA256Intrinsics, "need SHA256 instruction support");
+    state = get_state_from_sha_object(sha_obj);
+    stubAddr = StubRoutines::sha256_implCompress();
+    stubName = "sha256_implCompress";
+    break;
+  case vmIntrinsics::_sha5_implCompress:
+    assert(UseSHA512Intrinsics, "need SHA512 instruction support");
+    state = get_state_from_sha5_object(sha_obj);
+    stubAddr = StubRoutines::sha512_implCompress();
+    stubName = "sha512_implCompress";
+    break;
+  default:
+    fatal_unexpected_iid(id);
+    return false;
+  }
+  if (state == NULL) return false;
+
+  // Call the stub.
+  Node* call = make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::sha_implCompress_Type(),
+                                 stubAddr, stubName, TypePtr::BOTTOM,
+                                 src_start, state);
+
+  return true;
+}
+
+//------------------------------inline_digestBase_implCompressMB-----------------------
+//
+// Calculate SHA/SHA2/SHA5 for multi-block byte[] array.
+// int com.sun.security.provider.DigestBase.implCompressMultiBlock(byte[] b, int ofs, int limit)
+//
+bool LibraryCallKit::inline_digestBase_implCompressMB(int predicate) {
+  assert(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics,
+         "need SHA1/SHA256/SHA512 instruction support");
+  assert((uint)predicate < 3, "sanity");
+  assert(callee()->signature()->size() == 3, "digestBase_implCompressMB has 3 parameters");
+
+  Node* digestBase_obj = argument(0); // The receiver was checked for NULL already.
+  Node* src            = argument(1); // byte[] array
+  Node* ofs            = argument(2); // type int
+  Node* limit          = argument(3); // type int
+
+  const Type* src_type = src->Value(&_gvn);
+  const TypeAryPtr* top_src = src_type->isa_aryptr();
+  if (top_src  == NULL || top_src->klass()  == NULL) {
+    // failed array check
+    return false;
+  }
+  // Figure out the size and type of the elements we will be copying.
+  BasicType src_elem = src_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type();
+  if (src_elem != T_BYTE) {
+    return false;
+  }
+  // 'src_start' points to src array + offset
+  Node* src_start = array_element_address(src, ofs, src_elem);
+
+  const char* klass_SHA_name = NULL;
+  const char* stub_name = NULL;
+  address     stub_addr = NULL;
+  bool        long_state = false;
+
+  switch (predicate) {
+  case 0:
+    if (UseSHA1Intrinsics) {
+      klass_SHA_name = "sun/security/provider/SHA";
+      stub_name = "sha1_implCompressMB";
+      stub_addr = StubRoutines::sha1_implCompressMB();
+    }
+    break;
+  case 1:
+    if (UseSHA256Intrinsics) {
+      klass_SHA_name = "sun/security/provider/SHA2";
+      stub_name = "sha256_implCompressMB";
+      stub_addr = StubRoutines::sha256_implCompressMB();
+    }
+    break;
+  case 2:
+    if (UseSHA512Intrinsics) {
+      klass_SHA_name = "sun/security/provider/SHA5";
+      stub_name = "sha512_implCompressMB";
+      stub_addr = StubRoutines::sha512_implCompressMB();
+      long_state = true;
+    }
+    break;
+  default:
+    fatal(err_msg_res("unknown SHA intrinsic predicate: %d", predicate));
+  }
+  if (klass_SHA_name != NULL) {
+    // get DigestBase klass to lookup for SHA klass
+    const TypeInstPtr* tinst = _gvn.type(digestBase_obj)->isa_instptr();
+    assert(tinst != NULL, "digestBase_obj is not instance???");
+    assert(tinst->klass()->is_loaded(), "DigestBase is not loaded");
+
+    ciKlass* klass_SHA = tinst->klass()->as_instance_klass()->find_klass(ciSymbol::make(klass_SHA_name));
+    assert(klass_SHA->is_loaded(), "predicate checks that this class is loaded");
+    ciInstanceKlass* instklass_SHA = klass_SHA->as_instance_klass();
+    return inline_sha_implCompressMB(digestBase_obj, instklass_SHA, long_state, stub_addr, stub_name, src_start, ofs, limit);
+  }
+  return false;
+}
+//------------------------------inline_sha_implCompressMB-----------------------
+bool LibraryCallKit::inline_sha_implCompressMB(Node* digestBase_obj, ciInstanceKlass* instklass_SHA,
+                                               bool long_state, address stubAddr, const char *stubName,
+                                               Node* src_start, Node* ofs, Node* limit) {
+  const TypeKlassPtr* aklass = TypeKlassPtr::make(instklass_SHA);
+  const TypeOopPtr* xtype = aklass->as_instance_type();
+  Node* sha_obj = new CheckCastPPNode(control(), digestBase_obj, xtype);
+  sha_obj = _gvn.transform(sha_obj);
+
+  Node* state;
+  if (long_state) {
+    state = get_state_from_sha5_object(sha_obj);
+  } else {
+    state = get_state_from_sha_object(sha_obj);
+  }
+  if (state == NULL) return false;
+
+  // Call the stub.
+  Node* call = make_runtime_call(RC_LEAF|RC_NO_FP,
+                                 OptoRuntime::digestBase_implCompressMB_Type(),
+                                 stubAddr, stubName, TypePtr::BOTTOM,
+                                 src_start, state, ofs, limit);
+  // return ofs (int)
+  Node* result = _gvn.transform(new ProjNode(call, TypeFunc::Parms));
+  set_result(result);
+
+  return true;
+}
+
+//------------------------------get_state_from_sha_object-----------------------
+Node * LibraryCallKit::get_state_from_sha_object(Node *sha_object) {
+  Node* sha_state = load_field_from_object(sha_object, "state", "[I", /*is_exact*/ false);
+  assert (sha_state != NULL, "wrong version of sun.security.provider.SHA/SHA2");
+  if (sha_state == NULL) return (Node *) NULL;
+
+  // now have the array, need to get the start address of the state array
+  Node* state = array_element_address(sha_state, intcon(0), T_INT);
+  return state;
+}
+
+//------------------------------get_state_from_sha5_object-----------------------
+Node * LibraryCallKit::get_state_from_sha5_object(Node *sha_object) {
+  Node* sha_state = load_field_from_object(sha_object, "state", "[J", /*is_exact*/ false);
+  assert (sha_state != NULL, "wrong version of sun.security.provider.SHA5");
+  if (sha_state == NULL) return (Node *) NULL;
+
+  // now have the array, need to get the start address of the state array
+  Node* state = array_element_address(sha_state, intcon(0), T_LONG);
+  return state;
+}
+
+//----------------------------inline_digestBase_implCompressMB_predicate----------------------------
+// Return node representing slow path of predicate check.
+// the pseudo code we want to emulate with this predicate is:
+//    if (digestBaseObj instanceof SHA/SHA2/SHA5) do_intrinsic, else do_javapath
+//
+Node* LibraryCallKit::inline_digestBase_implCompressMB_predicate(int predicate) {
+  assert(UseSHA1Intrinsics || UseSHA256Intrinsics || UseSHA512Intrinsics,
+         "need SHA1/SHA256/SHA512 instruction support");
+  assert((uint)predicate < 3, "sanity");
+
+  // The receiver was checked for NULL already.
+  Node* digestBaseObj = argument(0);
+
+  // get DigestBase klass for instanceOf check
+  const TypeInstPtr* tinst = _gvn.type(digestBaseObj)->isa_instptr();
+  assert(tinst != NULL, "digestBaseObj is null");
+  assert(tinst->klass()->is_loaded(), "DigestBase is not loaded");
+
+  const char* klass_SHA_name = NULL;
+  switch (predicate) {
+  case 0:
+    if (UseSHA1Intrinsics) {
+      // we want to do an instanceof comparison against the SHA class
+      klass_SHA_name = "sun/security/provider/SHA";
+    }
+    break;
+  case 1:
+    if (UseSHA256Intrinsics) {
+      // we want to do an instanceof comparison against the SHA2 class
+      klass_SHA_name = "sun/security/provider/SHA2";
+    }
+    break;
+  case 2:
+    if (UseSHA512Intrinsics) {
+      // we want to do an instanceof comparison against the SHA5 class
+      klass_SHA_name = "sun/security/provider/SHA5";
+    }
+    break;
+  default:
+    fatal(err_msg_res("unknown SHA intrinsic predicate: %d", predicate));
+  }
+
+  ciKlass* klass_SHA = NULL;
+  if (klass_SHA_name != NULL) {
+    klass_SHA = tinst->klass()->as_instance_klass()->find_klass(ciSymbol::make(klass_SHA_name));
+  }
+  if ((klass_SHA == NULL) || !klass_SHA->is_loaded()) {
+    // if none of SHA/SHA2/SHA5 is loaded, we never take the intrinsic fast path
+    Node* ctrl = control();
+    set_control(top()); // no intrinsic path
+    return ctrl;
+  }
+  ciInstanceKlass* instklass_SHA = klass_SHA->as_instance_klass();
+
+  Node* instofSHA = gen_instanceof(digestBaseObj, makecon(TypeKlassPtr::make(instklass_SHA)));
+  Node* cmp_instof = _gvn.transform(new CmpINode(instofSHA, intcon(1)));
+  Node* bool_instof = _gvn.transform(new BoolNode(cmp_instof, BoolTest::ne));
+  Node* instof_false = generate_guard(bool_instof, NULL, PROB_MIN);
+
+  return instof_false;  // even if it is NULL
+}
--- a/src/share/vm/opto/loopPredicate.cpp	Thu Jun 19 11:22:25 2014 -0700
+++ b/src/share/vm/opto/loopPredicate.cpp	Fri Jun 20 10:15:08 2014 -0700
@@ -104,7 +104,7 @@
     assert(rgn->is_Call(), "must be call uct");
     CallNode* call = rgn->as_Call();
     IdealLoopTree* loop = get_loop(call);
-    rgn = new (C) RegionNode(1);
+    rgn = new RegionNode(1);
     rgn->add_req(uncommon_proj);
     register_control(rgn, loop, uncommon_proj);
     _igvn.hash_delete(call);
@@ -130,8 +130,8 @@
   IfNode *new_iff = iff->clone()->as_If();
   new_iff->set_req(0, entry);
   register_control(new_iff, lp, entry);
-  Node *if_cont = new (C) IfTrueNode(new_iff);
-  Node *if_uct  = new (C) IfFalseNode(new_iff);
+  Node *if_cont = new IfTrueNode(new_iff);
+  Node *if_uct  = new IfFalseNode(new_iff);
   if (cont_proj->is_IfFalse()) {
     // Swap
     Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp;
@@ -191,7 +191,7 @@
   if (!rgn->is_Region()) { // create a region to guard the call
     assert(rgn->is_Call(), "must be call uct");
     CallNode* call = rgn->as_Call();
-    rgn = new (C) RegionNode(1);
+    rgn = new RegionNode(1);
     register_new_node_with_optimizer(rgn);
     rgn->add_req(uncommon_proj);
     hash_delete(call);
@@ -208,8 +208,8 @@
   new_iff->set_req(0, new_entry);
 
   register_new_node_with_optimizer(new_iff);
-  Node *if_cont = new (C) IfTrueNode(new_iff);
-  Node *if_uct  = new (C) IfFalseNode(new_iff);
+  Node *if_cont = new IfTrueNode(new_iff);
+  Node *if_uct  = new IfFalseNode(new_iff);
   if (cont_proj->is_IfFalse()) {
     // Swap
     Node* tmp = if_uct; if_uct = if_cont; if_cont = tmp;
@@ -254,10 +254,10 @@
 
   // Match original condition since predicate's projections could be swapped.
   assert(predicate_proj->in(0)->in(1)->in(1)->Opcode()==Op_Opaque1, "must be");
-  Node* opq = new (igvn->C) Opaque1Node(igvn->C, predicate_proj->in(0)->in(1)->in(1)->in(1));
+  Node* opq = new Opaque1Node(igvn->C, predicate_proj->in(0)->in(1)->in(1)->in(1));
   igvn->C->add_predicate_opaq(opq);
 
-  Node* bol = new (igvn->C) Conv2BNode(opq);
+  Node* bol = new Conv2BNode(opq);
   if (loop_phase != NULL) {
     loop_phase->register_new_node(opq, ctrl);
     loop_phase->register_new_node(bol, ctrl);
@@ -605,11 +605,11 @@
       // Calculate exact limit here.
       // Note, counted loop's test is '<' or '>'.
       limit = exact_limit(loop);
-      max_idx_expr = new (C) SubINode(limit, stride);
+      max_idx_expr = new SubINode(limit, stride);
       register_new_node(max_idx_expr, ctrl);
       if (TraceLoopPredicate) predString->print("(limit - stride) ");
     } else {
-      max_idx_expr = new (C) SubINode(limit, stride);
+      max_idx_expr = new SubINode(limit, stride);
       register_new_node(max_idx_expr, ctrl);
       if (TraceLoopPredicate) predString->print("(limit - stride) ");
     }
@@ -619,22 +619,22 @@
 
   if (scale != 1) {
     ConNode* con_scale = _igvn.intcon(scale);
-    max_idx_expr = new (C) MulINode(max_idx_expr, con_scale);
+    max_idx_expr = new MulINode(max_idx_expr, con_scale);
     register_new_node(max_idx_expr, ctrl);
     if (TraceLoopPredicate) predString->print("* %d ", scale);
   }
 
   if (offset && (!offset->is_Con() || offset->get_int() != 0)){
-    max_idx_expr = new (C) AddINode(max_idx_expr, offset);
+    max_idx_expr = new AddINode(max_idx_expr, offset);
     register_new_node(max_idx_expr, ctrl);
     if (TraceLoopPredicate)
       if (offset->is_Con()) predString->print("+ %d ", offset->get_int());
       else predString->print("+ offset ");
   }
 
-  CmpUNode* cmp = new (C) CmpUNode(max_idx_expr, range);
+  CmpUNode* cmp = new CmpUNode(max_idx_expr, range);
   register_new_node(cmp, ctrl);
-  BoolNode* bol = new (C) BoolNode(cmp, BoolTest::lt);
+  BoolNode* bol = new BoolNode(cmp, BoolTest::lt);
   register_new_node(bol, ctrl);
 
   i