--- a/make/Makefile	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/Makefile	Tue Oct 13 12:04:21 2009 -0700
@@ -84,6 +84,7 @@
 C1_VM_TARGETS=product1 fastdebug1 optimized1 jvmg1
 C2_VM_TARGETS=product  fastdebug  optimized  jvmg
 KERNEL_VM_TARGETS=productkernel fastdebugkernel optimizedkernel jvmgkernel
+ZERO_VM_TARGETS=productzero fastdebugzero optimizedzero jvmgzero
 
 # JDK directory list
 JDK_DIRS=bin include jre lib demo
@@ -94,6 +95,12 @@
 all_debug:     jvmg jvmg1 jvmgkernel docs export_debug
 all_optimized: optimized optimized1 optimizedkernel docs export_optimized
 
+allzero:           all_productzero all_fastdebugzero
+all_productzero:   productzero docs export_product
+all_fastdebugzero: fastdebugzero docs export_fastdebug
+all_debugzero:     jvmgzero docs export_debug
+all_optimizedzero: optimizedzero docs export_optimized
+
 # Do everything
 world:         all create_jdk
 
@@ -120,6 +127,10 @@
 	$(CD) $(GAMMADIR)/make; \
 	$(MAKE) VM_TARGET=$@ generic_buildkernel $(ALT_OUT)
 
+$(ZERO_VM_TARGETS):
+	$(CD) $(GAMMADIR)/make; \
+	$(MAKE) VM_TARGET=$@ generic_buildzero $(ALT_OUT)
+
 # Build compiler1 (client) rule, different for platforms
 generic_build1:
 	$(MKDIR) -p $(OUTPUTDIR)
@@ -180,6 +191,12 @@
 	@$(ECHO) "No kernel ($(VM_TARGET)) for OS_NAME=$(OSNAME)"
 endif
 
+generic_buildzero:
+	$(MKDIR) -p $(OUTPUTDIR)
+	$(CD) $(OUTPUTDIR); \
+		$(MAKE) -f $(ABS_OS_MAKEFILE) \
+			$(MAKE_ARGS) $(VM_TARGET)
+
 # Export file rule
 generic_export: $(EXPORT_LIST)
 export_product:
@@ -210,11 +227,17 @@
 C1_BASE_DIR=$(OUTPUTDIR)/$(VM_PLATFORM)_compiler1
 C2_BASE_DIR=$(OUTPUTDIR)/$(VM_PLATFORM)_compiler2
 KERNEL_BASE_DIR=$(OUTPUTDIR)/$(VM_PLATFORM)_kernel
+ZERO_BASE_DIR=$(OUTPUTDIR)/$(VM_PLATFORM)_zero
 C1_DIR=$(C1_BASE_DIR)/$(VM_SUBDIR)
 C2_DIR=$(C2_BASE_DIR)/$(VM_SUBDIR)
 KERNEL_DIR=$(KERNEL_BASE_DIR)/$(VM_SUBDIR)
+ZERO_DIR=$(ZERO_BASE_DIR)/$(VM_SUBDIR)
 
 # Misc files and generated files need to come from C1 or C2 area
+ifeq ($(ZERO_BUILD), true)
+  MISC_DIR=$(ZERO_DIR)
+  GEN_DIR=$(ZERO_BASE_DIR)/generated
+else
 ifeq ($(ARCH_DATA_MODEL), 32)
   MISC_DIR=$(C1_DIR)
   GEN_DIR=$(C1_BASE_DIR)/generated
@@ -222,6 +245,7 @@
   MISC_DIR=$(C2_DIR)
   GEN_DIR=$(C2_BASE_DIR)/generated
 endif
+endif
 
 # Bin files (windows)
 ifeq ($(OSNAME),windows)
@@ -265,6 +289,12 @@
 
 # Shared Library
 ifneq ($(OSNAME),windows)
+  ifeq ($(ZERO_BUILD), true)
+$(EXPORT_JRE_LIB_ARCH_DIR)/%.so: $(ZERO_DIR)/%.so
+	$(install-file)
+$(EXPORT_SERVER_DIR)/%.so:       $(ZERO_DIR)/%.so
+	$(install-file)
+  else
 $(EXPORT_JRE_LIB_ARCH_DIR)/%.so: $(C2_DIR)/%.so
 	$(install-file)
 $(EXPORT_CLIENT_DIR)/%.so:       $(C1_DIR)/%.so
@@ -275,6 +305,7 @@
 	$(install-file)
 $(EXPORT_SERVER_DIR)/64/%.so:    $(C2_DIR)/%.so
 	$(install-file)
+  endif
 endif
 
 # Jar file (sa-jdi.jar)
@@ -313,6 +344,7 @@
 	$(RM) -r $(C1_DIR)
 	$(RM) -r $(C2_DIR)
 	$(RM) -r $(KERNEL_DIR)
+	$(RM) -r $(ZERO_DIR)
 clean_export:
 	$(RM) -r $(EXPORT_PATH)
 clean_jdk:
@@ -335,8 +367,10 @@
 	 ($(CD) $(JDK_IMAGE_DIR) && $(TAR) -xf -)
 
 test_jdk:
-  ifeq ($(ARCH_DATA_MODEL), 32)
+  ifneq ($(ZERO_BUILD), true)
+    ifeq ($(ARCH_DATA_MODEL), 32)
 	$(JDK_IMAGE_DIR)/bin/java -client -version
+    endif
   endif
 	$(JDK_IMAGE_DIR)/bin/java -server -version
 

--- a/make/defs.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/defs.make	Tue Oct 13 12:04:21 2009 -0700
@@ -192,13 +192,14 @@
 
   # Use uname output for SRCARCH, but deal with platform differences. If ARCH
   # is not explicitly listed below, it is treated as x86. 
-  SRCARCH     = $(ARCH/$(filter sparc sparc64 ia64 amd64 x86_64,$(ARCH)))
+  SRCARCH     = $(ARCH/$(filter sparc sparc64 ia64 amd64 x86_64 zero,$(ARCH)))
   ARCH/       = x86
   ARCH/sparc  = sparc
   ARCH/sparc64= sparc
   ARCH/ia64   = ia64
   ARCH/amd64  = x86
   ARCH/x86_64 = x86
+  ARCH/zero   = zero
 
   # BUILDARCH is usually the same as SRCARCH, except for sparcv9
   BUILDARCH = $(SRCARCH)
@@ -222,8 +223,9 @@
   LIBARCH/sparc   = sparc
   LIBARCH/sparcv9 = sparcv9
   LIBARCH/ia64    = ia64
+  LIBARCH/zero    = $(ZERO_LIBARCH)
 
-  LP64_ARCH = sparcv9 amd64 ia64
+  LP64_ARCH = sparcv9 amd64 ia64 zero
 endif
 
 # Required make macro settings for all platforms

--- a/make/linux/Makefile	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/Makefile	Tue Oct 13 12:04:21 2009 -0700
@@ -132,6 +132,9 @@
 
 endif
 
+# BUILDARCH is set to "zero" for Zero builds.  VARIANTARCH
+# is used to give the build directories meaningful names.
+VARIANTARCH = $(subst i386,i486,$(ZERO_LIBARCH))
 
 # There is a (semi-) regular correspondence between make targets and actions:
 #
@@ -158,6 +161,13 @@
 #       profiledcore    core            <os>_<arch>_core/profiled
 #       productcore     core            <os>_<arch>_core/product
 #
+#       debugzero       zero            <os>_<arch>_zero/debug
+#       fastdebugzero   zero            <os>_<arch>_zero/fastdebug
+#       jvmgzero        zero            <os>_<arch>_zero/jvmg
+#       optimizedzero   zero            <os>_<arch>_zero/optimized
+#       profiledzero    zero            <os>_<arch>_zero/profiled
+#       productzero     zero            <os>_<arch>_zero/product
+#
 # What you get with each target:
 #
 # debug*     - "thin" libjvm_g - debug info linked into the gamma_g launcher
@@ -171,16 +181,22 @@
 # in the build.sh script:
 TARGETS           = debug jvmg fastdebug optimized profiled product
 
-SUBDIR_DOCS       = $(OSNAME)_$(BUILDARCH)_docs
+ifeq ($(ZERO_BUILD), true)
+  SUBDIR_DOCS     = $(OSNAME)_$(VARIANTARCH)_docs
+else
+  SUBDIR_DOCS     = $(OSNAME)_$(BUILDARCH)_docs
+endif
 SUBDIRS_C1        = $(addprefix $(OSNAME)_$(BUILDARCH)_compiler1/,$(TARGETS))
 SUBDIRS_C2        = $(addprefix $(OSNAME)_$(BUILDARCH)_compiler2/,$(TARGETS))
 SUBDIRS_TIERED    = $(addprefix $(OSNAME)_$(BUILDARCH)_tiered/,$(TARGETS))
 SUBDIRS_CORE      = $(addprefix $(OSNAME)_$(BUILDARCH)_core/,$(TARGETS))
+SUBDIRS_ZERO      = $(addprefix $(OSNAME)_$(VARIANTARCH)_zero/,$(TARGETS))
 
 TARGETS_C2        = $(TARGETS)
 TARGETS_C1        = $(addsuffix 1,$(TARGETS))
 TARGETS_TIERED    = $(addsuffix tiered,$(TARGETS))
 TARGETS_CORE      = $(addsuffix core,$(TARGETS))
+TARGETS_ZERO      = $(addsuffix zero,$(TARGETS))
 
 BUILDTREE_MAKE    = $(GAMMADIR)/make/$(OSNAME)/makefiles/buildtree.make
 BUILDTREE_VARS    = GAMMADIR=$(GAMMADIR) OS_FAMILY=$(OSNAME) ARCH=$(SRCARCH) BUILDARCH=$(BUILDARCH) LIBARCH=$(LIBARCH)
@@ -196,6 +212,7 @@
 	@echo "  $(TARGETS_C2)"
 	@echo "  $(TARGETS_C1)"
 	@echo "  $(TARGETS_CORE)"
+	@echo "  $(TARGETS_ZERO)"
 
 checks: check_os_version check_j2se_version
 
@@ -245,6 +262,13 @@
 	$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
 	$(BUILDTREE) VARIANT=core
 
+$(SUBDIRS_ZERO): $(BUILDTREE_MAKE) platform_zero
+	$(QUIETLY) $(MAKE) -f $(GAMMADIR)/make/$(OSNAME)/Makefile checks
+	$(BUILDTREE) VARIANT=zero VARIANTARCH=$(VARIANTARCH)
+
+platform_zero: $(GAMMADIR)/make/$(OSNAME)/platform_zero.in
+	$(SED) 's/@ZERO_ARCHDEF@/$(ZERO_ARCHDEF)/g;s/@ZERO_LIBARCH@/$(ZERO_LIBARCH)/g;' < $< > $@
+
 # Define INSTALL=y at command line to automatically copy JVM into JAVA_HOME
 
 $(TARGETS_C2):  $(SUBDIRS_C2)
@@ -275,10 +299,18 @@
 	cd $(OSNAME)_$(BUILDARCH)_core/$(patsubst %core,%,$@) && $(MAKE) $(MFLAGS) install
 endif
 
+$(TARGETS_ZERO):  $(SUBDIRS_ZERO)
+	cd $(OSNAME)_$(VARIANTARCH)_zero/$(patsubst %zero,%,$@) && $(MAKE) $(MFLAGS)
+	cd $(OSNAME)_$(VARIANTARCH)_zero/$(patsubst %zero,%,$@) && ./test_gamma
+ifdef INSTALL
+	cd $(OSNAME)_$(VARIANTARCH)_zero/$(patsubst %zero,%,$@) && $(MAKE) $(MFLAGS) install
+endif
+
 # Just build the tree, and nothing else:
 tree:      $(SUBDIRS_C2)
 tree1:     $(SUBDIRS_C1)
 treecore:  $(SUBDIRS_CORE)
+treezero:  $(SUBDIRS_ZERO)
 
 # Doc target.  This is the same for all build options.
 #     Hence create a docs directory beside ...$(ARCH)_[...]
@@ -293,20 +325,22 @@
 
 core: jvmgcore productcore
 
+zero: jvmgzero productzero
+
 clean_docs:
 	rm -rf $(SUBDIR_DOCS)
 
-clean_compiler1 clean_compiler2 clean_core:
+clean_compiler1 clean_compiler2 clean_core clean_zero:
 	rm -rf $(OSNAME)_$(BUILDARCH)_$(subst clean_,,$@)
 
-clean:  clean_compiler2 clean_compiler1 clean_core clean_docs
+clean:  clean_compiler2 clean_compiler1 clean_core clean_zero clean_docs
 
 include $(GAMMADIR)/make/$(OSNAME)/makefiles/cscope.make
 
 #-------------------------------------------------------------------------------
 
-.PHONY: $(TARGETS_C2) $(TARGETS_C1) $(TARGETS_CORE)
-.PHONY: tree tree1 treecore
-.PHONY: all compiler1 compiler2 core
-.PHONY: clean clean_compiler1 clean_compiler2 clean_core docs clean_docs
+.PHONY: $(TARGETS_C2) $(TARGETS_C1) $(TARGETS_CORE) $(TARGETS_ZERO)
+.PHONY: tree tree1 treecore treezero
+.PHONY: all compiler1 compiler2 core zero
+.PHONY: clean clean_compiler1 clean_compiler2 clean_core clean_zero docs clean_docs
 .PHONY: checks check_os_version check_j2se_version

--- a/make/linux/makefiles/buildtree.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/makefiles/buildtree.make	Tue Oct 13 12:04:21 2009 -0700
@@ -63,20 +63,30 @@
 # For now, until the compiler is less wobbly:
 TESTFLAGS	= -Xbatch -showversion
 
-ifdef USE_SUNCC
-PLATFORM_FILE	= $(GAMMADIR)/make/$(OS_FAMILY)/platform_$(BUILDARCH).suncc
+ifeq ($(ZERO_BUILD), true)
+  PLATFORM_FILE = $(shell dirname $(shell dirname $(shell pwd)))/platform_zero
 else
-PLATFORM_FILE   = $(GAMMADIR)/make/$(OS_FAMILY)/platform_$(BUILDARCH)
+  ifdef USE_SUNCC
+    PLATFORM_FILE = $(GAMMADIR)/make/$(OS_FAMILY)/platform_$(BUILDARCH).suncc
+  else
+    PLATFORM_FILE = $(GAMMADIR)/make/$(OS_FAMILY)/platform_$(BUILDARCH)
+  endif
+endif
+
+# Allow overriding of the arch part of the directory but default
+# to BUILDARCH if nothing is specified
+ifeq ($(VARIANTARCH),)
+  VARIANTARCH=$(BUILDARCH)
 endif
 
 ifdef FORCE_TIERED
 ifeq		($(VARIANT),tiered)
-PLATFORM_DIR	= $(OS_FAMILY)_$(BUILDARCH)_compiler2
+PLATFORM_DIR	= $(OS_FAMILY)_$(VARIANTARCH)_compiler2
 else
-PLATFORM_DIR	= $(OS_FAMILY)_$(BUILDARCH)_$(VARIANT)
+PLATFORM_DIR	= $(OS_FAMILY)_$(VARIANTARCH)_$(VARIANT)
 endif
 else
-PLATFORM_DIR    = $(OS_FAMILY)_$(BUILDARCH)_$(VARIANT)
+PLATFORM_DIR    = $(OS_FAMILY)_$(VARIANTARCH)_$(VARIANT)
 endif
 
 #
@@ -321,6 +331,7 @@
 DATA_MODE/sparcv9 = 64
 DATA_MODE/amd64   = 64
 DATA_MODE/ia64    = 64
+DATA_MODE/zero    = $(ARCH_DATA_MODEL)
 
 JAVA_FLAG/32 = -d32
 JAVA_FLAG/64 = -d64

--- a/make/linux/makefiles/defs.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/makefiles/defs.make	Tue Oct 13 12:04:21 2009 -0700
@@ -37,6 +37,17 @@
   ARCH_DATA_MODEL ?= 32
 endif
 
+# zero
+ifeq ($(ZERO_BUILD), true)
+  ifeq ($(ARCH_DATA_MODEL), 64)
+    MAKE_ARGS      += LP64=1
+  endif
+  PLATFORM         = linux-zero
+  VM_PLATFORM      = linux_$(subst i386,i486,$(ZERO_LIBARCH))
+  HS_ARCH          = zero
+  ARCH             = zero
+endif
+
 # ia64
 ifeq ($(ARCH), ia64)
   ARCH_DATA_MODEL = 64
@@ -97,17 +108,19 @@
 EXPORT_LIST += $(EXPORT_SERVER_DIR)/Xusage.txt
 EXPORT_LIST += $(EXPORT_SERVER_DIR)/libjsig.so
 EXPORT_LIST += $(EXPORT_SERVER_DIR)/libjvm.so
-ifeq ($(ARCH_DATA_MODEL), 32)
-  EXPORT_CLIENT_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/client
-  EXPORT_LIST += $(EXPORT_CLIENT_DIR)/Xusage.txt
-  EXPORT_LIST += $(EXPORT_CLIENT_DIR)/libjsig.so
-  EXPORT_LIST += $(EXPORT_CLIENT_DIR)/libjvm.so 
-  EXPORT_LIST += $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.so
-  EXPORT_LIST += $(EXPORT_LIB_DIR)/sa-jdi.jar 
-else
-  ifeq ($(ARCH),ia64)
-    else
-      EXPORT_LIST += $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.so
-      EXPORT_LIST += $(EXPORT_LIB_DIR)/sa-jdi.jar
+ifneq ($(ZERO_BUILD), true)
+  ifeq ($(ARCH_DATA_MODEL), 32)
+    EXPORT_CLIENT_DIR = $(EXPORT_JRE_LIB_ARCH_DIR)/client
+    EXPORT_LIST += $(EXPORT_CLIENT_DIR)/Xusage.txt
+    EXPORT_LIST += $(EXPORT_CLIENT_DIR)/libjsig.so
+    EXPORT_LIST += $(EXPORT_CLIENT_DIR)/libjvm.so 
+    EXPORT_LIST += $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.so
+    EXPORT_LIST += $(EXPORT_LIB_DIR)/sa-jdi.jar 
+  else
+    ifeq ($(ARCH),ia64)
+      else
+        EXPORT_LIST += $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.so
+        EXPORT_LIST += $(EXPORT_LIB_DIR)/sa-jdi.jar
     endif
+  endif
 endif

--- a/make/linux/makefiles/gcc.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/makefiles/gcc.make	Tue Oct 13 12:04:21 2009 -0700
@@ -52,6 +52,9 @@
 VM_PICFLAG/AOUT   =
 VM_PICFLAG        = $(VM_PICFLAG/$(LINK_INTO))
 
+ifeq ($(ZERO_BUILD), true)
+CFLAGS += $(LIBFFI_CFLAGS)
+endif
 CFLAGS += $(VM_PICFLAG)
 CFLAGS += -fno-rtti
 CFLAGS += -fno-exceptions
@@ -64,6 +67,7 @@
 ARCHFLAG/ia64    =
 ARCHFLAG/sparc   = -m32 -mcpu=v9
 ARCHFLAG/sparcv9 = -m64 -mcpu=v9
+ARCHFLAG/zero    = $(ZERO_ARCHFLAG)
 
 CFLAGS     += $(ARCHFLAG)
 AOUT_FLAGS += $(ARCHFLAG)

--- a/make/linux/makefiles/sa.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/makefiles/sa.make	Tue Oct 13 12:04:21 2009 -0700
@@ -52,10 +52,10 @@
 SA_PROPERTIES = $(SA_CLASSDIR)/sa.properties
 
 # if $(AGENT_DIR) does not exist, we don't build SA
-# also, we don't build SA on Itanium.
+# also, we don't build SA on Itanium or zero.
 
 all: 
-	if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" ] ; then \
+	if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" -a "$(SRCARCH)" != "zero" ] ; then \
 	   $(MAKE) -f sa.make $(GENERATED)/sa-jdi.jar; \
 	fi
 

--- a/make/linux/makefiles/saproc.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/makefiles/saproc.make	Tue Oct 13 12:04:21 2009 -0700
@@ -49,10 +49,10 @@
 endif
 
 # if $(AGENT_DIR) does not exist, we don't build SA
-# also, we don't build SA on Itanium.
+# also, we don't build SA on Itanium or zero.
 
 checkAndBuildSA:
-	$(QUIETLY) if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" ] ; then \
+	$(QUIETLY) if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" -a "$(SRCARCH)" != "zero" ] ; then \
 	   $(MAKE) -f vm.make $(LIBSAPROC); \
 	fi
 

--- a/make/linux/makefiles/top.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/makefiles/top.make	Tue Oct 13 12:04:21 2009 -0700
@@ -74,6 +74,7 @@
 Include_DBs/COMPILER1   = $(Include_DBs/CORE) $(VM)/includeDB_compiler1
 Include_DBs/COMPILER2   = $(Include_DBs/CORE) $(VM)/includeDB_compiler2
 Include_DBs/TIERED      = $(Include_DBs/CORE) $(VM)/includeDB_compiler1 $(VM)/includeDB_compiler2
+Include_DBs/ZERO        = $(Include_DBs/CORE) $(VM)/includeDB_zero
 Include_DBs = $(Include_DBs/$(TYPE))
 
 Cached_plat = $(GENERATED)/platform.current

--- a/make/linux/makefiles/vm.make	Wed Oct 07 15:38:37 2009 -0700
+++ b/make/linux/makefiles/vm.make	Tue Oct 13 12:04:21 2009 -0700
@@ -40,7 +40,11 @@
 include $(GENERATED)/Dependencies
 
 # read machine-specific adjustments (%%% should do this via buildtree.make?)
-include $(MAKEFILES_DIR)/$(BUILDARCH).make
+ifeq ($(ZERO_BUILD), true)
+  include $(MAKEFILES_DIR)/zeroshark.make
+else
+  include $(MAKEFILES_DIR)/$(BUILDARCH).make
+endif
 
 # set VPATH so make knows where to look for source files
 # Src_Dirs is everything in src/share/vm/*, plus the right os/*/vm and cpu/*/vm
@@ -124,7 +128,11 @@
 	rm -f $@
 	cat $^ > $@
 
-STATIC_CXX = true
+ifeq ($(ZERO_LIBARCH), ppc64)
+  STATIC_CXX = false
+else
+  STATIC_CXX = true
+endif
 
 ifeq ($(LINK_INTO),AOUT)
   LIBJVM.o                 =
@@ -148,6 +156,9 @@
 
   LIBS_VM                  += $(LIBS)
 endif
+ifeq ($(ZERO_BUILD), true)
+  LIBS_VM += $(LIBFFI_LIBS)
+endif
 
 LINK_VM = $(LINK_LIB.c)
 

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/make/linux/makefiles/zero.make	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,32 @@
+#
+# Copyright 1999-2008 Sun Microsystems, Inc.  All Rights Reserved.
+# Copyright 2009 Red Hat, Inc.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This code is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 2 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# version 2 for more details (a copy is included in the LICENSE file that
+# accompanied this code).
+#
+# You should have received a copy of the GNU General Public License version
+# 2 along with this work; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+#  
+#
+
+# Setup for Zero (non-Shark) version of VM
+
+# Select which includeDB files to use (in top.make)
+TYPE = ZERO
+
+# Install libjvm.so, etc in in server directory.
+VM_SUBDIR = server

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/make/linux/makefiles/zeroshark.make	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,43 @@
+#
+# Copyright 2003-2005 Sun Microsystems, Inc.  All Rights Reserved.
+# Copyright 2007, 2008 Red Hat, Inc.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# This code is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 2 only, as
+# published by the Free Software Foundation.
+#
+# This code is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# version 2 for more details (a copy is included in the LICENSE file that
+# accompanied this code).
+#
+# You should have received a copy of the GNU General Public License version
+# 2 along with this work; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+# Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+# CA 95054 USA or visit www.sun.com if you need additional information or
+# have any questions.
+#
+#
+
+# Setup common to Zero (non-Shark) and Shark versions of VM
+
+# The copied fdlibm routines in sharedRuntimeTrig.o must not be optimized
+OPT_CFLAGS/sharedRuntimeTrig.o = $(OPT_CFLAGS/NOOPT)
+# The copied fdlibm routines in sharedRuntimeTrans.o must not be optimized
+OPT_CFLAGS/sharedRuntimeTrans.o = $(OPT_CFLAGS/NOOPT)
+
+# Specify that the CPU is little endian, if necessary
+ifeq ($(ZERO_ENDIANNESS), little)
+  CFLAGS += -DVM_LITTLE_ENDIAN
+endif
+
+# Specify that the CPU is 64 bit, if necessary
+ifeq ($(ARCH_DATA_MODEL), 64)
+  CFLAGS += -D_LP64=1
+endif
+
+OPT_CFLAGS/compactingPermGenGen.o = -O1

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/make/linux/platform_zero.in	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,17 @@
+os_family = linux
+
+arch = zero
+
+arch_model = zero
+
+os_arch = linux_zero
+
+os_arch_model = linux_zero
+
+lib_arch = zero
+
+compiler = gcc
+
+gnu_dis_arch = zero
+
+sysdefs = -DLINUX -D_GNU_SOURCE -DCC_INTERP -DZERO -D@ZERO_ARCHDEF@ -DZERO_LIBARCH=\"@ZERO_LIBARCH@\"

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/assembler_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007, 2008, 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_assembler_zero.cpp.incl"
+
+int AbstractAssembler::code_fill_byte() {
+  return 0;
+}
+
+void Assembler::pd_patch_instruction(address branch, address target) {
+  ShouldNotCallThis();
+}
+
+#ifndef PRODUCT
+void Assembler::pd_print_patched_instruction(address branch) {
+  ShouldNotCallThis();
+}
+#endif // PRODUCT
+
+void MacroAssembler::align(int modulus) {
+  while (offset() % modulus != 0)
+    emit_byte(AbstractAssembler::code_fill_byte());
+}
+
+void MacroAssembler::bang_stack_with_offset(int offset) {
+  ShouldNotCallThis();
+}
+
+void MacroAssembler::advance(int bytes) {
+  _code_pos += bytes;
+  sync();
+}
+
+RegisterOrConstant MacroAssembler::delayed_value_impl(
+  intptr_t* delayed_value_addr, Register tmpl, int offset) {
+  ShouldNotCallThis();
+}
+
+void MacroAssembler::store_oop(jobject obj) {
+  code_section()->relocate(pc(), oop_Relocation::spec_for_immediate());
+  emit_address((address) obj);
+}
+
+static void should_not_call() {
+  report_should_not_call(__FILE__, __LINE__);
+}
+
+address ShouldNotCallThisStub() {
+  return (address) should_not_call;
+}
+
+address ShouldNotCallThisEntry() {
+  return (address) should_not_call;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/assembler_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,64 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007, 2008, 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// In normal, CPU-specific ports of HotSpot these two classes are used
+// for generating assembly language.  We don't do any of this in zero,
+// of course, but we do sneak entry points around in CodeBuffers so we
+// generate those here.
+
+class Assembler : public AbstractAssembler {
+ public:
+  Assembler(CodeBuffer* code) : AbstractAssembler(code) {}
+
+ public:
+  void pd_patch_instruction(address branch, address target);
+#ifndef PRODUCT
+  static void pd_print_patched_instruction(address branch);
+#endif // PRODUCT
+};
+
+class MacroAssembler : public Assembler {
+ public:
+  MacroAssembler(CodeBuffer* code) : Assembler(code) {}
+
+ public:
+  void align(int modulus);
+  void bang_stack_with_offset(int offset);
+  bool needs_explicit_null_check(intptr_t offset);
+  RegisterOrConstant delayed_value_impl(intptr_t* delayed_value_addr,
+                                        Register tmp, int offset);
+ public:
+  void advance(int bytes);
+  void store_oop(jobject obj);
+};
+
+#ifdef ASSERT
+inline bool AbstractAssembler::pd_check_instruction_mark() {
+  ShouldNotCallThis();
+}
+#endif
+
+address ShouldNotCallThisStub();
+address ShouldNotCallThisEntry();

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/assembler_zero.inline.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,26 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// This file is intentionally empty

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/bytecodeInterpreter_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_cppInterpreter_zero.cpp.incl"
+
+#ifdef CC_INTERP
+
+const char *BytecodeInterpreter::name_of_field_at_address(address addr) {
+#define DO(member) {if (addr == (address) &(member)) return XSTR(member);}
+  DO(_thread);
+  DO(_bcp);
+  DO(_locals);
+  DO(_constants);
+  DO(_method);
+  DO(_mdx);
+  DO(_stack);
+  DO(_msg);
+  DO(_result);
+  DO(_prev_link);
+  DO(_oop_temp);
+  DO(_stack_base);
+  DO(_stack_limit);
+  DO(_monitor_base);
+  DO(_self_link);
+#undef DO
+  if (addr > (address) &_result && addr < (address) (&_result + 1))
+    return "_result)";
+  return NULL;
+}
+
+#endif // CC_INTERP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/bytecodeInterpreter_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2002 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007, 2008 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// Platform specific for C++ based Interpreter
+
+#if defined(PPC) || defined(SPARC) || defined(IA64)
+#define LOTS_OF_REGS   // Use plenty of registers
+#else
+#undef LOTS_OF_REGS    // Loser platforms
+#endif
+
+ private:
+  interpreterState _self_link;
+
+ public:
+  inline void set_locals(intptr_t* new_locals) {
+    _locals = new_locals;
+  }
+  inline void set_method(methodOop new_method) {
+    _method = new_method;
+  }
+  inline interpreterState self_link() {
+    return _self_link;
+  }
+  inline void set_self_link(interpreterState new_self_link) {
+    _self_link = new_self_link;
+  }
+  inline interpreterState prev_link() {
+    return _prev_link;
+  }
+  inline void set_prev_link(interpreterState new_prev_link) {
+    _prev_link = new_prev_link;
+  }
+  inline void set_stack_limit(intptr_t* new_stack_limit) {
+    _stack_limit = new_stack_limit;
+  }
+  inline void set_stack_base(intptr_t* new_stack_base) {
+    _stack_base = new_stack_base;
+  }
+  inline void set_monitor_base(BasicObjectLock *new_monitor_base) {
+    _monitor_base = new_monitor_base;
+  }
+  inline void set_thread(JavaThread* new_thread) {
+    _thread = new_thread;
+  }
+  inline void set_constants(constantPoolCacheOop new_constants) {
+    _constants = new_constants;
+  }
+  inline oop oop_temp() {
+    return _oop_temp;
+  }
+  inline oop *oop_temp_addr() {
+    return &_oop_temp;
+  }
+  inline void set_oop_temp(oop new_oop_temp) {
+    _oop_temp = new_oop_temp;
+  }
+  inline address callee_entry_point() {
+    return _result._to_call._callee_entry_point;
+  }
+  inline address osr_buf() {
+    return _result._osr._osr_buf;
+  }
+  inline address osr_entry() {
+    return _result._osr._osr_entry;
+  }
+
+ public:
+  const char *name_of_field_at_address(address addr);
+
+// The frame manager handles this
+#define SET_LAST_JAVA_FRAME()
+#define RESET_LAST_JAVA_FRAME()
+
+// ZeroStack Implementation
+
+#undef STACK_INT
+#undef STACK_FLOAT
+#undef STACK_ADDR
+#undef STACK_OBJECT
+#undef STACK_DOUBLE
+#undef STACK_LONG
+
+#define GET_STACK_SLOT(offset)    (*((intptr_t*) &topOfStack[-(offset)]))
+#define STACK_SLOT(offset)    ((address) &topOfStack[-(offset)])
+#define STACK_ADDR(offset)    (*((address *) &topOfStack[-(offset)]))
+#define STACK_INT(offset)     (*((jint*) &topOfStack[-(offset)]))
+#define STACK_FLOAT(offset)   (*((jfloat *) &topOfStack[-(offset)]))
+#define STACK_OBJECT(offset)  (*((oop *) &topOfStack [-(offset)]))
+#define STACK_DOUBLE(offset)  (((VMJavaVal64*) &topOfStack[-(offset)])->d)
+#define STACK_LONG(offset)    (((VMJavaVal64 *) &topOfStack[-(offset)])->l)
+
+#define SET_STACK_SLOT(value, offset)   (*(intptr_t*)&topOfStack[-(offset)] = *(intptr_t*)(value))
+#define SET_STACK_ADDR(value, offset)   (*((address *)&topOfStack[-(offset)]) = (value))
+#define SET_STACK_INT(value, offset)    (*((jint *)&topOfStack[-(offset)]) = (value))
+#define SET_STACK_FLOAT(value, offset)  (*((jfloat *)&topOfStack[-(offset)]) = (value))
+#define SET_STACK_OBJECT(value, offset) (*((oop *)&topOfStack[-(offset)]) = (value))
+#define SET_STACK_DOUBLE(value, offset) (((VMJavaVal64*)&topOfStack[-(offset)])->d = (value))
+#define SET_STACK_DOUBLE_FROM_ADDR(addr, offset) (((VMJavaVal64*)&topOfStack[-(offset)])->d =  \
+                                                 ((VMJavaVal64*)(addr))->d)
+#define SET_STACK_LONG(value, offset)   (((VMJavaVal64*)&topOfStack[-(offset)])->l = (value))
+#define SET_STACK_LONG_FROM_ADDR(addr, offset)   (((VMJavaVal64*)&topOfStack[-(offset)])->l =  \
+                                                 ((VMJavaVal64*)(addr))->l)
+// JavaLocals implementation
+
+#define LOCALS_SLOT(offset)    ((intptr_t*)&locals[-(offset)])
+#define LOCALS_ADDR(offset)    ((address)locals[-(offset)])
+#define LOCALS_INT(offset)     (*((jint*)&locals[-(offset)]))
+#define LOCALS_FLOAT(offset)   (*((jfloat*)&locals[-(offset)]))
+#define LOCALS_OBJECT(offset)  ((oop)locals[-(offset)])
+#define LOCALS_DOUBLE(offset)  (((VMJavaVal64*)&locals[-((offset) + 1)])->d)
+#define LOCALS_LONG(offset)    (((VMJavaVal64*)&locals[-((offset) + 1)])->l)
+#define LOCALS_LONG_AT(offset) (((address)&locals[-((offset) + 1)]))
+#define LOCALS_DOUBLE_AT(offset) (((address)&locals[-((offset) + 1)]))
+
+#define SET_LOCALS_SLOT(value, offset)    (*(intptr_t*)&locals[-(offset)] = *(intptr_t *)(value))
+#define SET_LOCALS_ADDR(value, offset)    (*((address *)&locals[-(offset)]) = (value))
+#define SET_LOCALS_INT(value, offset)     (*((jint *)&locals[-(offset)]) = (value))
+#define SET_LOCALS_FLOAT(value, offset)   (*((jfloat *)&locals[-(offset)]) = (value))
+#define SET_LOCALS_OBJECT(value, offset)  (*((oop *)&locals[-(offset)]) = (value))
+#define SET_LOCALS_DOUBLE(value, offset)  (((VMJavaVal64*)&locals[-((offset)+1)])->d = (value))
+#define SET_LOCALS_LONG(value, offset)    (((VMJavaVal64*)&locals[-((offset)+1)])->l = (value))
+#define SET_LOCALS_DOUBLE_FROM_ADDR(addr, offset) (((VMJavaVal64*)&locals[-((offset)+1)])->d = \
+                                                  ((VMJavaVal64*)(addr))->d)
+#define SET_LOCALS_LONG_FROM_ADDR(addr, offset) (((VMJavaVal64*)&locals[-((offset)+1)])->l = \
+                                                ((VMJavaVal64*)(addr))->l)

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/bytecodeInterpreter_zero.inline.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,301 @@
+/*
+ * Copyright 2002 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// Inline interpreter functions for zero
+
+inline jfloat BytecodeInterpreter::VMfloatAdd(jfloat op1, jfloat op2) {
+  return op1 + op2;
+}
+
+inline jfloat BytecodeInterpreter::VMfloatSub(jfloat op1, jfloat op2) {
+  return op1 - op2;
+}
+
+inline jfloat BytecodeInterpreter::VMfloatMul(jfloat op1, jfloat op2) {
+  return op1 * op2;
+}
+
+inline jfloat BytecodeInterpreter::VMfloatDiv(jfloat op1, jfloat op2) {
+  return op1 / op2;
+}
+
+inline jfloat BytecodeInterpreter::VMfloatRem(jfloat op1, jfloat op2) {
+  return fmod(op1, op2);
+}
+
+inline jfloat BytecodeInterpreter::VMfloatNeg(jfloat op) {
+  return -op;
+}
+
+inline int32_t BytecodeInterpreter::VMfloatCompare(jfloat  op1,
+                                                   jfloat  op2,
+                                                   int32_t direction) {
+  return ( op1 < op2 ? -1 :
+               op1 > op2 ? 1 :
+                   op1 == op2 ? 0 :
+                       (direction == -1 || direction == 1) ? direction : 0);
+
+}
+
+inline void BytecodeInterpreter::VMmemCopy64(uint32_t       to[2],
+                                             const uint32_t from[2]) {
+  *(uint64_t *) to = *(uint64_t *) from;
+}
+
+inline jlong BytecodeInterpreter::VMlongAdd(jlong op1, jlong op2) {
+  return op1 + op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongAnd(jlong op1, jlong op2) {
+  return op1 & op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongDiv(jlong op1, jlong op2) {
+  /* it's possible we could catch this special case implicitly */
+  if (op1 == (jlong) 0x8000000000000000LL && op2 == -1) return op1;
+  else return op1 / op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongMul(jlong op1, jlong op2) {
+  return op1 * op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongOr(jlong op1, jlong op2) {
+  return op1 | op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongSub(jlong op1, jlong op2) {
+  return op1 - op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongXor(jlong op1, jlong op2) {
+  return op1 ^ op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongRem(jlong op1, jlong op2) {
+  /* it's possible we could catch this special case implicitly */
+  if (op1 == (jlong) 0x8000000000000000LL && op2 == -1) return 0;
+  else return op1 % op2;
+}
+
+inline jlong BytecodeInterpreter::VMlongUshr(jlong op1, jint op2) {
+  return ((unsigned long long) op1) >> (op2 & 0x3F);
+}
+
+inline jlong BytecodeInterpreter::VMlongShr(jlong op1, jint op2) {
+  return op1 >> (op2 & 0x3F);
+}
+
+inline jlong BytecodeInterpreter::VMlongShl(jlong op1, jint op2) {
+  return op1 << (op2 & 0x3F);
+}
+
+inline jlong BytecodeInterpreter::VMlongNeg(jlong op) {
+  return -op;
+}
+
+inline jlong BytecodeInterpreter::VMlongNot(jlong op) {
+  return ~op;
+}
+
+inline int32_t BytecodeInterpreter::VMlongLtz(jlong op) {
+  return (op <= 0);
+}
+
+inline int32_t BytecodeInterpreter::VMlongGez(jlong op) {
+  return (op >= 0);
+}
+
+inline int32_t BytecodeInterpreter::VMlongEqz(jlong op) {
+  return (op == 0);
+}
+
+inline int32_t BytecodeInterpreter::VMlongEq(jlong op1, jlong op2) {
+  return (op1 == op2);
+}
+
+inline int32_t BytecodeInterpreter::VMlongNe(jlong op1, jlong op2) {
+  return (op1 != op2);
+}
+
+inline int32_t BytecodeInterpreter::VMlongGe(jlong op1, jlong op2) {
+  return (op1 >= op2);
+}
+
+inline int32_t BytecodeInterpreter::VMlongLe(jlong op1, jlong op2) {
+  return (op1 <= op2);
+}
+
+inline int32_t BytecodeInterpreter::VMlongLt(jlong op1, jlong op2) {
+  return (op1 < op2);
+}
+
+inline int32_t BytecodeInterpreter::VMlongGt(jlong op1, jlong op2) {
+  return (op1 > op2);
+}
+
+inline int32_t BytecodeInterpreter::VMlongCompare(jlong op1, jlong op2) {
+  return (VMlongLt(op1, op2) ? -1 : VMlongGt(op1, op2) ? 1 : 0);
+}
+
+// Long conversions
+
+inline jdouble BytecodeInterpreter::VMlong2Double(jlong val) {
+  return (jdouble) val;
+}
+
+inline jfloat BytecodeInterpreter::VMlong2Float(jlong val) {
+  return (jfloat) val;
+}
+
+inline jint BytecodeInterpreter::VMlong2Int(jlong val) {
+  return (jint) val;
+}
+
+// Double Arithmetic
+
+inline jdouble BytecodeInterpreter::VMdoubleAdd(jdouble op1, jdouble op2) {
+  return op1 + op2;
+}
+
+inline jdouble BytecodeInterpreter::VMdoubleDiv(jdouble op1, jdouble op2) {
+  // Divide by zero... QQQ
+  return op1 / op2;
+}
+
+inline jdouble BytecodeInterpreter::VMdoubleMul(jdouble op1, jdouble op2) {
+  return op1 * op2;
+}
+
+inline jdouble BytecodeInterpreter::VMdoubleNeg(jdouble op) {
+  return -op;
+}
+
+inline jdouble BytecodeInterpreter::VMdoubleRem(jdouble op1, jdouble op2) {
+  return fmod(op1, op2);
+}
+
+inline jdouble BytecodeInterpreter::VMdoubleSub(jdouble op1, jdouble op2) {
+  return op1 - op2;
+}
+
+inline int32_t BytecodeInterpreter::VMdoubleCompare(jdouble op1,
+                                                    jdouble op2,
+                                                    int32_t direction) {
+  return ( op1 < op2 ? -1 :
+               op1 > op2 ? 1 :
+                   op1 == op2 ? 0 :
+                       (direction == -1 || direction == 1) ? direction : 0);
+}
+
+// Double Conversions
+
+inline jfloat BytecodeInterpreter::VMdouble2Float(jdouble val) {
+  return (jfloat) val;
+}
+
+// Float Conversions
+
+inline jdouble BytecodeInterpreter::VMfloat2Double(jfloat op) {
+  return (jdouble) op;
+}
+
+// Integer Arithmetic
+
+inline jint BytecodeInterpreter::VMintAdd(jint op1, jint op2) {
+  return op1 + op2;
+}
+
+inline jint BytecodeInterpreter::VMintAnd(jint op1, jint op2) {
+  return op1 & op2;
+}
+
+inline jint BytecodeInterpreter::VMintDiv(jint op1, jint op2) {
+  /* it's possible we could catch this special case implicitly */
+  if (op1 == (jint) 0x80000000 && op2 == -1) return op1;
+  else return op1 / op2;
+}
+
+inline jint BytecodeInterpreter::VMintMul(jint op1, jint op2) {
+  return op1 * op2;
+}
+
+inline jint BytecodeInterpreter::VMintNeg(jint op) {
+  return -op;
+}
+
+inline jint BytecodeInterpreter::VMintOr(jint op1, jint op2) {
+  return op1 | op2;
+}
+
+inline jint BytecodeInterpreter::VMintRem(jint op1, jint op2) {
+  /* it's possible we could catch this special case implicitly */
+  if (op1 == (jint) 0x80000000 && op2 == -1) return 0;
+  else return op1 % op2;
+}
+
+inline jint BytecodeInterpreter::VMintShl(jint op1, jint op2) {
+  return op1 << (op2 & 0x1F);
+}
+
+inline jint BytecodeInterpreter::VMintShr(jint op1, jint op2) {
+  return op1 >> (op2 & 0x1F);
+}
+
+inline jint BytecodeInterpreter::VMintSub(jint op1, jint op2) {
+  return op1 - op2;
+}
+
+inline jint BytecodeInterpreter::VMintUshr(jint op1, jint op2) {
+  return ((juint) op1) >> (op2 & 0x1F);
+}
+
+inline jint BytecodeInterpreter::VMintXor(jint op1, jint op2) {
+  return op1 ^ op2;
+}
+
+inline jdouble BytecodeInterpreter::VMint2Double(jint val) {
+  return (jdouble) val;
+}
+
+inline jfloat BytecodeInterpreter::VMint2Float(jint val) {
+  return (jfloat) val;
+}
+
+inline jlong BytecodeInterpreter::VMint2Long(jint val) {
+  return (jlong) val;
+}
+
+inline jchar BytecodeInterpreter::VMint2Char(jint val) {
+  return (jchar) val;
+}
+
+inline jshort BytecodeInterpreter::VMint2Short(jint val) {
+  return (jshort) val;
+}
+
+inline jbyte BytecodeInterpreter::VMint2Byte(jint val) {
+  return (jbyte) val;
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/bytecodes_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2003 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_bytecodes_zero.cpp.incl"
+
+void Bytecodes::pd_initialize() {
+  // No zero specific initialization
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/bytecodes_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,26 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// This file is intentionally empty

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/bytes_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,164 @@
+/*
+ * Copyright 1997-2002 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007, 2008, 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+typedef union unaligned {
+  u4 u;
+  u2 us;
+  u8 ul;
+} __attribute__((packed)) unaligned;
+
+class Bytes: AllStatic {
+ public:
+  // Returns true if the byte ordering used by Java is different
+  // from the native byte ordering of the underlying machine.
+  static inline bool is_Java_byte_ordering_different() {
+#ifdef VM_LITTLE_ENDIAN
+    return true;
+#else
+    return false;
+#endif
+  }
+
+  // Efficient reading and writing of unaligned unsigned data in
+  // platform-specific byte ordering.
+  static inline u2 get_native_u2(address p){
+    unaligned *up = (unaligned *) p;
+    return up->us;
+  }
+
+  static inline u4 get_native_u4(address p) {
+    unaligned *up = (unaligned *) p;
+    return up->u;
+  }
+
+  static inline u8 get_native_u8(address p) {
+    unaligned *up = (unaligned *) p;
+    return up->ul;
+  }
+
+  static inline void put_native_u2(address p, u2 x) {
+    unaligned *up = (unaligned *) p;
+    up->us = x;
+  }
+
+  static inline void put_native_u4(address p, u4 x) {
+    unaligned *up = (unaligned *) p;
+    up->u = x;
+  }
+
+  static inline void put_native_u8(address p, u8 x) {
+    unaligned *up = (unaligned *) p;
+    up->ul = x;
+  }
+
+  // Efficient reading and writing of unaligned unsigned data in Java
+  // byte ordering (i.e. big-endian ordering).
+#ifdef VM_LITTLE_ENDIAN
+  // Byte-order reversal is needed
+  static inline u2 get_Java_u2(address p) {
+    return (u2(p[0]) << 8) |
+           (u2(p[1])     );
+  }
+  static inline u4 get_Java_u4(address p) {
+    return (u4(p[0]) << 24) |
+           (u4(p[1]) << 16) |
+           (u4(p[2]) <<  8) |
+           (u4(p[3])      );
+  }
+  static inline u8 get_Java_u8(address p) {
+    u4 hi, lo;
+    hi = (u4(p[0]) << 24) |
+         (u4(p[1]) << 16) |
+         (u4(p[2]) <<  8) |
+         (u4(p[3])      );
+    lo = (u4(p[4]) << 24) |
+         (u4(p[5]) << 16) |
+         (u4(p[6]) <<  8) |
+         (u4(p[7])      );
+    return u8(lo) | (u8(hi) << 32);
+  }
+
+  static inline void put_Java_u2(address p, u2 x) {
+    p[0] = x >> 8;
+    p[1] = x;
+  }
+  static inline void put_Java_u4(address p, u4 x) {
+    p[0] = x >> 24;
+    p[1] = x >> 16;
+    p[2] = x >> 8;
+    p[3] = x;
+  }
+  static inline void put_Java_u8(address p, u8 x) {
+    u4 hi, lo;
+    lo = x;
+    hi = x >> 32;
+    p[0] = hi >> 24;
+    p[1] = hi >> 16;
+    p[2] = hi >> 8;
+    p[3] = hi;
+    p[4] = lo >> 24;
+    p[5] = lo >> 16;
+    p[6] = lo >> 8;
+    p[7] = lo;
+  }
+
+  // Efficient swapping of byte ordering
+  static inline u2 swap_u2(u2 x);
+  static inline u4 swap_u4(u4 x);
+  static inline u8 swap_u8(u8 x);
+#else
+  // No byte-order reversal is needed
+  static inline u2 get_Java_u2(address p) {
+    return get_native_u2(p);
+  }
+  static inline u4 get_Java_u4(address p) {
+    return get_native_u4(p);
+  }
+  static inline u8 get_Java_u8(address p) {
+    return get_native_u8(p);
+  }
+
+  static inline void put_Java_u2(address p, u2 x) {
+    put_native_u2(p, x);
+  }
+  static inline void put_Java_u4(address p, u4 x) {
+    put_native_u4(p, x);
+  }
+  static inline void put_Java_u8(address p, u8 x) {
+    put_native_u8(p, x);
+  }
+
+  // No byte-order reversal is needed
+  static inline u2 swap_u2(u2 x) { return x; }
+  static inline u4 swap_u4(u4 x) { return x; }
+  static inline u8 swap_u8(u8 x) { return x; }
+#endif // VM_LITTLE_ENDIAN
+};
+
+#ifdef VM_LITTLE_ENDIAN
+// The following header contains the implementations of swap_u2,
+// swap_u4, and swap_u8
+#include "incls/_bytes_pd.inline.hpp.incl"
+#endif // VM_LITTLE_ENDIAN

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/codeBuffer_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2003-2005 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+ private:
+  void pd_initialize() {}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/copy_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2003-2004 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// Inline functions for memory copy and fill.
+
+static void pd_conjoint_words(HeapWord* from, HeapWord* to, size_t count) {
+  memmove(to, from, count * HeapWordSize);
+}
+
+static void pd_disjoint_words(HeapWord* from, HeapWord* to, size_t count) {
+  switch (count) {
+  case 8:  to[7] = from[7];
+  case 7:  to[6] = from[6];
+  case 6:  to[5] = from[5];
+  case 5:  to[4] = from[4];
+  case 4:  to[3] = from[3];
+  case 3:  to[2] = from[2];
+  case 2:  to[1] = from[1];
+  case 1:  to[0] = from[0];
+  case 0:  break;
+  default:
+    memcpy(to, from, count * HeapWordSize);
+    break;
+  }
+}
+
+static void pd_disjoint_words_atomic(HeapWord* from,
+                                     HeapWord* to,
+                                     size_t count) {
+  switch (count) {
+  case 8:  to[7] = from[7];
+  case 7:  to[6] = from[6];
+  case 6:  to[5] = from[5];
+  case 5:  to[4] = from[4];
+  case 4:  to[3] = from[3];
+  case 3:  to[2] = from[2];
+  case 2:  to[1] = from[1];
+  case 1:  to[0] = from[0];
+  case 0:  break;
+  default:
+    while (count-- > 0) {
+      *to++ = *from++;
+    }
+    break;
+  }
+}
+
+static void pd_aligned_conjoint_words(HeapWord* from,
+                                      HeapWord* to,
+                                      size_t count) {
+  memmove(to, from, count * HeapWordSize);
+}
+
+static void pd_aligned_disjoint_words(HeapWord* from,
+                                      HeapWord* to,
+                                      size_t count) {
+  pd_disjoint_words(from, to, count);
+}
+
+static void pd_conjoint_bytes(void* from, void* to, size_t count) {
+  memmove(to, from, count);
+}
+
+static void pd_conjoint_bytes_atomic(void* from, void* to, size_t count) {
+  memmove(to, from, count);
+}
+
+static void pd_conjoint_jshorts_atomic(jshort* from, jshort* to, size_t count) {
+  _Copy_conjoint_jshorts_atomic(from, to, count);
+}
+
+static void pd_conjoint_jints_atomic(jint* from, jint* to, size_t count) {
+  _Copy_conjoint_jints_atomic(from, to, count);
+}
+
+static void pd_conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) {
+  _Copy_conjoint_jlongs_atomic(from, to, count);
+}
+
+static void pd_conjoint_oops_atomic(oop* from, oop* to, size_t count) {
+#ifdef _LP64
+  assert(BytesPerLong == BytesPerOop, "jlongs and oops must be the same size");
+  _Copy_conjoint_jlongs_atomic((jlong*)from, (jlong*)to, count);
+#else
+  assert(BytesPerInt == BytesPerOop, "jints and oops must be the same size");
+  _Copy_conjoint_jints_atomic((jint*)from, (jint*)to, count);
+#endif // _LP64
+}
+
+static void pd_arrayof_conjoint_bytes(HeapWord* from,
+                                      HeapWord* to,
+                                      size_t    count) {
+  _Copy_arrayof_conjoint_bytes(from, to, count);
+}
+
+static void pd_arrayof_conjoint_jshorts(HeapWord* from,
+                                        HeapWord* to,
+                                        size_t    count) {
+  _Copy_arrayof_conjoint_jshorts(from, to, count);
+}
+
+static void pd_arrayof_conjoint_jints(HeapWord* from,
+                                      HeapWord* to,
+                                      size_t    count) {
+  _Copy_arrayof_conjoint_jints(from, to, count);
+}
+
+static void pd_arrayof_conjoint_jlongs(HeapWord* from,
+                                       HeapWord* to,
+                                       size_t    count) {
+  _Copy_arrayof_conjoint_jlongs(from, to, count);
+}
+
+static void pd_arrayof_conjoint_oops(HeapWord* from,
+                                     HeapWord* to,
+                                     size_t    count) {
+#ifdef _LP64
+  assert(BytesPerLong == BytesPerOop, "jlongs and oops must be the same size");
+  _Copy_arrayof_conjoint_jlongs(from, to, count);
+#else
+  assert(BytesPerInt == BytesPerOop, "jints and oops must be the same size");
+  _Copy_arrayof_conjoint_jints(from, to, count);
+#endif // _LP64
+}
+
+static void pd_fill_to_words(HeapWord* tohw, size_t count, juint value) {
+#ifdef _LP64
+  julong* to = (julong*) tohw;
+  julong  v  = ((julong) value << 32) | value;
+#else
+  juint* to = (juint*) tohw;
+  juint  v  = value;
+#endif // _LP64
+
+  while (count-- > 0) {
+    *to++ = v;
+  }
+}
+
+static void pd_fill_to_aligned_words(HeapWord* tohw,
+                                     size_t    count,
+                                     juint     value) {
+  pd_fill_to_words(tohw, count, value);
+}
+
+static void pd_fill_to_bytes(void* to, size_t count, jubyte value) {
+  memset(to, value, count);
+}
+
+static void pd_zero_to_words(HeapWord* tohw, size_t count) {
+  pd_fill_to_words(tohw, count, 0);
+}
+
+static void pd_zero_to_bytes(void* to, size_t count) {
+  memset(to, 0, count);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/cppInterpreterGenerator_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008, 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+ protected:
+  MacroAssembler* assembler() const {
+    return _masm;
+  }
+
+ protected:
+  address generate_entry(address entry_point) {
+    ZeroEntry *entry = (ZeroEntry *) assembler()->pc();
+    assembler()->advance(sizeof(ZeroEntry));
+    entry->set_entry_point(entry_point);
+    return (address) entry;
+  }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/cppInterpreter_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,946 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007, 2008, 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_cppInterpreter_zero.cpp.incl"
+
+#ifdef CC_INTERP
+
+#define fixup_after_potential_safepoint()       \
+  method = istate->method()
+
+#define CALL_VM_NOCHECK(func)                   \
+  thread->set_last_Java_frame();                \
+  func;                                         \
+  thread->reset_last_Java_frame();              \
+  fixup_after_potential_safepoint()
+
+void CppInterpreter::normal_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+  JavaThread *thread = (JavaThread *) THREAD;
+  ZeroStack *stack = thread->zero_stack();
+
+  // Adjust the caller's stack frame to accomodate any additional
+  // local variables we have contiguously with our parameters.
+  int extra_locals = method->max_locals() - method->size_of_parameters();
+  if (extra_locals > 0) {
+    if (extra_locals > stack->available_words()) {
+      Unimplemented();
+    }
+    for (int i = 0; i < extra_locals; i++)
+      stack->push(0);
+  }
+
+  // Allocate and initialize our frame.
+  InterpreterFrame *frame = InterpreterFrame::build(stack, method, thread);
+  thread->push_zero_frame(frame);
+
+  // Execute those bytecodes!
+  main_loop(0, THREAD);
+}
+
+void CppInterpreter::main_loop(int recurse, TRAPS) {
+  JavaThread *thread = (JavaThread *) THREAD;
+  ZeroStack *stack = thread->zero_stack();
+
+  // If we are entering from a deopt we may need to call
+  // ourself a few times in order to get to our frame.
+  if (recurse)
+    main_loop(recurse - 1, THREAD);
+
+  InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
+  interpreterState istate = frame->interpreter_state();
+  methodOop method = istate->method();
+
+  intptr_t *result = NULL;
+  int result_slots = 0;
+
+  // Check we're not about to run out of stack
+  if (stack_overflow_imminent(thread)) {
+    CALL_VM_NOCHECK(InterpreterRuntime::throw_StackOverflowError(thread));
+    goto unwind_and_return;
+  }
+
+  while (true) {
+    // We can set up the frame anchor with everything we want at
+    // this point as we are thread_in_Java and no safepoints can
+    // occur until we go to vm mode.  We do have to clear flags
+    // on return from vm but that is it.
+    thread->set_last_Java_frame();
+
+    // Call the interpreter
+    if (JvmtiExport::can_post_interpreter_events())
+      BytecodeInterpreter::runWithChecks(istate);
+    else
+      BytecodeInterpreter::run(istate);
+    fixup_after_potential_safepoint();
+
+    // Clear the frame anchor
+    thread->reset_last_Java_frame();
+
+    // Examine the message from the interpreter to decide what to do
+    if (istate->msg() == BytecodeInterpreter::call_method) {
+      methodOop callee = istate->callee();
+
+      // Trim back the stack to put the parameters at the top
+      stack->set_sp(istate->stack() + 1);
+
+      // Make the call
+      Interpreter::invoke_method(callee, istate->callee_entry_point(), THREAD);
+      fixup_after_potential_safepoint();
+
+      // Convert the result
+      istate->set_stack(stack->sp() - 1);
+
+      // Restore the stack
+      stack->set_sp(istate->stack_limit() + 1);
+
+      // Resume the interpreter
+      istate->set_msg(BytecodeInterpreter::method_resume);
+    }
+    else if (istate->msg() == BytecodeInterpreter::more_monitors) {
+      int monitor_words = frame::interpreter_frame_monitor_size();
+
+      // Allocate the space
+      if (monitor_words > stack->available_words()) {
+        Unimplemented();
+      }
+      stack->alloc(monitor_words * wordSize);
+
+      // Move the expression stack contents
+      for (intptr_t *p = istate->stack() + 1; p < istate->stack_base(); p++)
+        *(p - monitor_words) = *p;
+
+      // Move the expression stack pointers
+      istate->set_stack_limit(istate->stack_limit() - monitor_words);
+      istate->set_stack(istate->stack() - monitor_words);
+      istate->set_stack_base(istate->stack_base() - monitor_words);
+
+      // Zero the new monitor so the interpreter can find it.
+      ((BasicObjectLock *) istate->stack_base())->set_obj(NULL);
+
+      // Resume the interpreter
+      istate->set_msg(BytecodeInterpreter::got_monitors);
+    }
+    else if (istate->msg() == BytecodeInterpreter::return_from_method) {
+      // Copy the result into the caller's frame
+      result_slots = type2size[method->result_type()];
+      assert(result_slots >= 0 && result_slots <= 2, "what?");
+      result = istate->stack() + result_slots;
+      break;
+    }
+    else if (istate->msg() == BytecodeInterpreter::throwing_exception) {
+      assert(HAS_PENDING_EXCEPTION, "should do");
+      break;
+    }
+    else if (istate->msg() == BytecodeInterpreter::do_osr) {
+      // Unwind the current frame
+      thread->pop_zero_frame();
+
+      // Remove any extension of the previous frame
+      int extra_locals = method->max_locals() - method->size_of_parameters();
+      stack->set_sp(stack->sp() + extra_locals);
+
+      // Jump into the OSR method
+      Interpreter::invoke_osr(
+        method, istate->osr_entry(), istate->osr_buf(), THREAD);
+      return;
+    }
+    else {
+      ShouldNotReachHere();
+    }
+  }
+
+ unwind_and_return:
+
+  // Unwind the current frame
+  thread->pop_zero_frame();
+
+  // Pop our local variables
+  stack->set_sp(stack->sp() + method->max_locals());
+
+  // Push our result
+  for (int i = 0; i < result_slots; i++)
+    stack->push(result[-i]);
+}
+
+void CppInterpreter::native_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+  // Make sure method is native and not abstract
+  assert(method->is_native() && !method->is_abstract(), "should be");
+
+  JavaThread *thread = (JavaThread *) THREAD;
+  ZeroStack *stack = thread->zero_stack();
+
+  // Allocate and initialize our frame
+  InterpreterFrame *frame = InterpreterFrame::build(stack, method, thread);
+  thread->push_zero_frame(frame);
+  interpreterState istate = frame->interpreter_state();
+  intptr_t *locals = istate->locals();
+
+  // Check we're not about to run out of stack
+  if (stack_overflow_imminent(thread)) {
+    CALL_VM_NOCHECK(InterpreterRuntime::throw_StackOverflowError(thread));
+    goto unwind_and_return;
+  }
+
+  // Lock if necessary
+  BasicObjectLock *monitor;
+  monitor = NULL;
+  if (method->is_synchronized()) {
+    monitor = (BasicObjectLock*) istate->stack_base();
+    oop lockee = monitor->obj();
+    markOop disp = lockee->mark()->set_unlocked();
+
+    monitor->lock()->set_displaced_header(disp);
+    if (Atomic::cmpxchg_ptr(monitor, lockee->mark_addr(), disp) != disp) {
+      if (thread->is_lock_owned((address) disp->clear_lock_bits())) {
+        monitor->lock()->set_displaced_header(NULL);
+      }
+      else {
+        CALL_VM_NOCHECK(InterpreterRuntime::monitorenter(thread, monitor));
+        if (HAS_PENDING_EXCEPTION)
+          goto unwind_and_return;
+      }
+    }
+  }
+
+  // Get the signature handler
+  InterpreterRuntime::SignatureHandler *handler; {
+    address handlerAddr = method->signature_handler();
+    if (handlerAddr == NULL) {
+      CALL_VM_NOCHECK(InterpreterRuntime::prepare_native_call(thread, method));
+      if (HAS_PENDING_EXCEPTION)
+        goto unwind_and_return;
+
+      handlerAddr = method->signature_handler();
+      assert(handlerAddr != NULL, "eh?");
+    }
+    if (handlerAddr == (address) InterpreterRuntime::slow_signature_handler) {
+      CALL_VM_NOCHECK(handlerAddr =
+        InterpreterRuntime::slow_signature_handler(thread, method, NULL,NULL));
+      if (HAS_PENDING_EXCEPTION)
+        goto unwind_and_return;
+    }
+    handler = \
+      InterpreterRuntime::SignatureHandler::from_handlerAddr(handlerAddr);
+  }
+
+  // Get the native function entry point
+  address function;
+  function = method->native_function();
+  assert(function != NULL, "should be set if signature handler is");
+
+  // Build the argument list
+  if (handler->argument_count() * 2 > stack->available_words()) {
+    Unimplemented();
+  }
+  void **arguments;
+  void *mirror; {
+    arguments =
+      (void **) stack->alloc(handler->argument_count() * sizeof(void **));
+    void **dst = arguments;
+
+    void *env = thread->jni_environment();
+    *(dst++) = &env;
+
+    if (method->is_static()) {
+      istate->set_oop_temp(
+        method->constants()->pool_holder()->klass_part()->java_mirror());
+      mirror = istate->oop_temp_addr();
+      *(dst++) = &mirror;
+    }
+
+    intptr_t *src = locals;
+    for (int i = dst - arguments; i < handler->argument_count(); i++) {
+      ffi_type *type = handler->argument_type(i);
+      if (type == &ffi_type_pointer) {
+        if (*src) {
+          stack->push((intptr_t) src);
+          *(dst++) = stack->sp();
+        }
+        else {
+          *(dst++) = src;
+        }
+        src--;
+      }
+      else if (type->size == 4) {
+        *(dst++) = src--;
+      }
+      else if (type->size == 8) {
+        src--;
+        *(dst++) = src--;
+      }
+      else {
+        ShouldNotReachHere();
+      }
+    }
+  }
+
+  // Set up the Java frame anchor
+  thread->set_last_Java_frame();
+
+  // Change the thread state to _thread_in_native
+  ThreadStateTransition::transition_from_java(thread, _thread_in_native);
+
+  // Make the call
+  intptr_t result[4 - LogBytesPerWord];
+  ffi_call(handler->cif(), (void (*)()) function, result, arguments);
+
+  // Change the thread state back to _thread_in_Java.
+  // ThreadStateTransition::transition_from_native() cannot be used
+  // here because it does not check for asynchronous exceptions.
+  // We have to manage the transition ourself.
+  thread->set_thread_state(_thread_in_native_trans);
+
+  // Make sure new state is visible in the GC thread
+  if (os::is_MP()) {
+    if (UseMembar) {
+      OrderAccess::fence();
+    }
+    else {
+      InterfaceSupport::serialize_memory(thread);
+    }
+  }
+
+  // Handle safepoint operations, pending suspend requests,
+  // and pending asynchronous exceptions.
+  if (SafepointSynchronize::do_call_back() ||
+      thread->has_special_condition_for_native_trans()) {
+    JavaThread::check_special_condition_for_native_trans(thread);
+    CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops());
+  }
+
+  // Finally we can change the thread state to _thread_in_Java.
+  thread->set_thread_state(_thread_in_Java);
+  fixup_after_potential_safepoint();
+
+  // Clear the frame anchor
+  thread->reset_last_Java_frame();
+
+  // If the result was an oop then unbox it and store it in
+  // oop_temp where the garbage collector can see it before
+  // we release the handle it might be protected by.
+  if (handler->result_type() == &ffi_type_pointer) {
+    if (result[0])
+      istate->set_oop_temp(*(oop *) result[0]);
+    else
+      istate->set_oop_temp(NULL);
+  }
+
+  // Reset handle block
+  thread->active_handles()->clear();
+
+  // Unlock if necessary.  It seems totally wrong that this
+  // is skipped in the event of an exception but apparently
+  // the template interpreter does this so we do too.
+  if (monitor && !HAS_PENDING_EXCEPTION) {
+    BasicLock *lock = monitor->lock();
+    markOop header = lock->displaced_header();
+    oop rcvr = monitor->obj();
+    monitor->set_obj(NULL);
+
+    if (header != NULL) {
+      if (Atomic::cmpxchg_ptr(header, rcvr->mark_addr(), lock) != lock) {
+        monitor->set_obj(rcvr); {
+          HandleMark hm(thread);
+          CALL_VM_NOCHECK(InterpreterRuntime::monitorexit(thread, monitor));
+        }
+      }
+    }
+  }
+
+ unwind_and_return:
+
+  // Unwind the current activation
+  thread->pop_zero_frame();
+
+  // Pop our parameters
+  stack->set_sp(stack->sp() + method->size_of_parameters());
+
+  // Push our result
+  if (!HAS_PENDING_EXCEPTION) {
+    stack->set_sp(stack->sp() - type2size[method->result_type()]);
+
+    switch (method->result_type()) {
+    case T_VOID:
+      break;
+
+    case T_BOOLEAN:
+#ifndef VM_LITTLE_ENDIAN
+      result[0] <<= (BitsPerWord - BitsPerByte);
+#endif
+      SET_LOCALS_INT(*(jboolean *) result != 0, 0);
+      break;
+
+    case T_CHAR:
+#ifndef VM_LITTLE_ENDIAN
+      result[0] <<= (BitsPerWord - BitsPerShort);
+#endif
+      SET_LOCALS_INT(*(jchar *) result, 0);
+      break;
+
+    case T_BYTE:
+#ifndef VM_LITTLE_ENDIAN
+      result[0] <<= (BitsPerWord - BitsPerByte);
+#endif
+      SET_LOCALS_INT(*(jbyte *) result, 0);
+      break;
+
+    case T_SHORT:
+#ifndef VM_LITTLE_ENDIAN
+      result[0] <<= (BitsPerWord - BitsPerShort);
+#endif
+      SET_LOCALS_INT(*(jshort *) result, 0);
+      break;
+
+    case T_INT:
+#ifndef VM_LITTLE_ENDIAN
+      result[0] <<= (BitsPerWord - BitsPerInt);
+#endif
+      SET_LOCALS_INT(*(jint *) result, 0);
+      break;
+
+    case T_LONG:
+      SET_LOCALS_LONG(*(jlong *) result, 0);
+      break;
+
+    case T_FLOAT:
+      SET_LOCALS_FLOAT(*(jfloat *) result, 0);
+      break;
+
+    case T_DOUBLE:
+      SET_LOCALS_DOUBLE(*(jdouble *) result, 0);
+      break;
+
+    case T_OBJECT:
+    case T_ARRAY:
+      SET_LOCALS_OBJECT(istate->oop_temp(), 0);
+      break;
+
+    default:
+      ShouldNotReachHere();
+    }
+  }
+}
+
+void CppInterpreter::accessor_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+  JavaThread *thread = (JavaThread *) THREAD;
+  ZeroStack *stack = thread->zero_stack();
+  intptr_t *locals = stack->sp();
+
+  // Drop into the slow path if we need a safepoint check
+  if (SafepointSynchronize::do_call_back()) {
+    normal_entry(method, 0, THREAD);
+    return;
+  }
+
+  // Load the object pointer and drop into the slow path
+  // if we have a NullPointerException
+  oop object = LOCALS_OBJECT(0);
+  if (object == NULL) {
+    normal_entry(method, 0, THREAD);
+    return;
+  }
+
+  // Read the field index from the bytecode, which looks like this:
+  //  0:  aload_0
+  //  1:  getfield
+  //  2:    index
+  //  3:    index
+  //  4:  ireturn/areturn
+  // NB this is not raw bytecode: index is in machine order
+  u1 *code = method->code_base();
+  assert(code[0] == Bytecodes::_aload_0 &&
+         code[1] == Bytecodes::_getfield &&
+         (code[4] == Bytecodes::_ireturn ||
+          code[4] == Bytecodes::_areturn), "should do");
+  u2 index = Bytes::get_native_u2(&code[2]);
+
+  // Get the entry from the constant pool cache, and drop into
+  // the slow path if it has not been resolved
+  constantPoolCacheOop cache = method->constants()->cache();
+  ConstantPoolCacheEntry* entry = cache->entry_at(index);
+  if (!entry->is_resolved(Bytecodes::_getfield)) {
+    normal_entry(method, 0, THREAD);
+    return;
+  }
+
+  // Get the result and push it onto the stack
+  switch (entry->flag_state()) {
+  case ltos:
+  case dtos:
+    if (stack->available_words() < 1) {
+      Unimplemented();
+    }
+    stack->alloc(wordSize);
+    break;
+  }
+  if (entry->is_volatile()) {
+    switch (entry->flag_state()) {
+    case ctos:
+      SET_LOCALS_INT(object->char_field_acquire(entry->f2()), 0);
+      break;
+
+    case btos:
+      SET_LOCALS_INT(object->byte_field_acquire(entry->f2()), 0);
+      break;
+
+    case stos:
+      SET_LOCALS_INT(object->short_field_acquire(entry->f2()), 0);
+      break;
+
+    case itos:
+      SET_LOCALS_INT(object->int_field_acquire(entry->f2()), 0);
+      break;
+
+    case ltos:
+      SET_LOCALS_LONG(object->long_field_acquire(entry->f2()), 0);
+      break;
+
+    case ftos:
+      SET_LOCALS_FLOAT(object->float_field_acquire(entry->f2()), 0);
+      break;
+
+    case dtos:
+      SET_LOCALS_DOUBLE(object->double_field_acquire(entry->f2()), 0);
+      break;
+
+    case atos:
+      SET_LOCALS_OBJECT(object->obj_field_acquire(entry->f2()), 0);
+      break;
+
+    default:
+      ShouldNotReachHere();
+    }
+  }
+  else {
+    switch (entry->flag_state()) {
+    case ctos:
+      SET_LOCALS_INT(object->char_field(entry->f2()), 0);
+      break;
+
+    case btos:
+      SET_LOCALS_INT(object->byte_field(entry->f2()), 0);
+      break;
+
+    case stos:
+      SET_LOCALS_INT(object->short_field(entry->f2()), 0);
+      break;
+
+    case itos:
+      SET_LOCALS_INT(object->int_field(entry->f2()), 0);
+      break;
+
+    case ltos:
+      SET_LOCALS_LONG(object->long_field(entry->f2()), 0);
+      break;
+
+    case ftos:
+      SET_LOCALS_FLOAT(object->float_field(entry->f2()), 0);
+      break;
+
+    case dtos:
+      SET_LOCALS_DOUBLE(object->double_field(entry->f2()), 0);
+      break;
+
+    case atos:
+      SET_LOCALS_OBJECT(object->obj_field(entry->f2()), 0);
+      break;
+
+    default:
+      ShouldNotReachHere();
+    }
+  }
+}
+
+void CppInterpreter::empty_entry(methodOop method, intptr_t UNUSED, TRAPS) {
+  JavaThread *thread = (JavaThread *) THREAD;
+  ZeroStack *stack = thread->zero_stack();
+
+  // Drop into the slow path if we need a safepoint check
+  if (SafepointSynchronize::do_call_back()) {
+    normal_entry(method, 0, THREAD);
+    return;
+  }
+
+  // Pop our parameters
+  stack->set_sp(stack->sp() + method->size_of_parameters());
+}
+
+bool CppInterpreter::stack_overflow_imminent(JavaThread *thread) {
+  // How is the ABI stack?
+  address stack_top = thread->stack_base() - thread->stack_size();
+  int free_stack = os::current_stack_pointer() - stack_top;
+  if (free_stack < StackShadowPages * os::vm_page_size()) {
+    return true;
+  }
+
+  // How is the Zero stack?
+  // Throwing a StackOverflowError involves a VM call, which means
+  // we need a frame on the stack.  We should be checking here to
+  // ensure that methods we call have enough room to install the
+  // largest possible frame, but that's more than twice the size
+  // of the entire Zero stack we get by default, so we just check
+  // we have *some* space instead...
+  free_stack = thread->zero_stack()->available_words() * wordSize;
+  if (free_stack < StackShadowPages * os::vm_page_size()) {
+    return true;
+  }
+
+  return false;
+}
+
+InterpreterFrame *InterpreterFrame::build(ZeroStack*       stack,
+                                          const methodOop  method,
+                                          JavaThread*      thread) {
+  int monitor_words =
+    method->is_synchronized() ? frame::interpreter_frame_monitor_size() : 0;
+  int stack_words = method->is_native() ? 0 : method->max_stack();
+
+  if (header_words + monitor_words + stack_words > stack->available_words()) {
+    Unimplemented();
+  }
+
+  intptr_t *locals;
+  if (method->is_native())
+    locals = stack->sp() + (method->size_of_parameters() - 1);
+  else
+    locals = stack->sp() + (method->max_locals() - 1);
+
+  stack->push(0); // next_frame, filled in later
+  intptr_t *fp = stack->sp();
+  assert(fp - stack->sp() == next_frame_off, "should be");
+
+  stack->push(INTERPRETER_FRAME);
+  assert(fp - stack->sp() == frame_type_off, "should be");
+
+  interpreterState istate =
+    (interpreterState) stack->alloc(sizeof(BytecodeInterpreter));
+  assert(fp - stack->sp() == istate_off, "should be");
+
+  istate->set_locals(locals);
+  istate->set_method(method);
+  istate->set_self_link(istate);
+  istate->set_prev_link(NULL);
+  istate->set_thread(thread);
+  istate->set_bcp(method->is_native() ? NULL : method->code_base());
+  istate->set_constants(method->constants()->cache());
+  istate->set_msg(BytecodeInterpreter::method_entry);
+  istate->set_oop_temp(NULL);
+  istate->set_mdx(NULL);
+  istate->set_callee(NULL);
+
+  istate->set_monitor_base((BasicObjectLock *) stack->sp());
+  if (method->is_synchronized()) {
+    BasicObjectLock *monitor =
+      (BasicObjectLock *) stack->alloc(monitor_words * wordSize);
+    oop object;
+    if (method->is_static())
+      object = method->constants()->pool_holder()->klass_part()->java_mirror();
+    else
+      object = (oop) locals[0];
+    monitor->set_obj(object);
+  }
+
+  istate->set_stack_base(stack->sp());
+  istate->set_stack(stack->sp() - 1);
+  if (stack_words)
+    stack->alloc(stack_words * wordSize);
+  istate->set_stack_limit(stack->sp() - 1);
+
+  return (InterpreterFrame *) fp;
+}
+
+int AbstractInterpreter::BasicType_as_index(BasicType type) {
+  int i = 0;
+  switch (type) {
+    case T_BOOLEAN: i = 0; break;
+    case T_CHAR   : i = 1; break;
+    case T_BYTE   : i = 2; break;
+    case T_SHORT  : i = 3; break;
+    case T_INT    : i = 4; break;
+    case T_LONG   : i = 5; break;
+    case T_VOID   : i = 6; break;
+    case T_FLOAT  : i = 7; break;
+    case T_DOUBLE : i = 8; break;
+    case T_OBJECT : i = 9; break;
+    case T_ARRAY  : i = 9; break;
+    default       : ShouldNotReachHere();
+  }
+  assert(0 <= i && i < AbstractInterpreter::number_of_result_handlers,
+         "index out of bounds");
+  return i;
+}
+
+address InterpreterGenerator::generate_empty_entry() {
+  if (!UseFastEmptyMethods)
+    return NULL;
+
+  return generate_entry((address) CppInterpreter::empty_entry);
+}
+
+address InterpreterGenerator::generate_accessor_entry() {
+  if (!UseFastAccessorMethods)
+    return NULL;
+
+  return generate_entry((address) CppInterpreter::accessor_entry);
+}
+
+address InterpreterGenerator::generate_native_entry(bool synchronized) {
+  assert(synchronized == false, "should be");
+
+  return generate_entry((address) CppInterpreter::native_entry);
+}
+
+address InterpreterGenerator::generate_normal_entry(bool synchronized) {
+  assert(synchronized == false, "should be");
+
+  return generate_entry((address) CppInterpreter::normal_entry);
+}
+
+address AbstractInterpreterGenerator::generate_method_entry(
+    AbstractInterpreter::MethodKind kind) {
+  address entry_point = NULL;
+
+  switch (kind) {
+  case Interpreter::zerolocals:
+  case Interpreter::zerolocals_synchronized:
+    break;
+
+  case Interpreter::native:
+    entry_point = ((InterpreterGenerator*) this)->generate_native_entry(false);
+    break;
+
+  case Interpreter::native_synchronized:
+    entry_point = ((InterpreterGenerator*) this)->generate_native_entry(false);
+    break;
+
+  case Interpreter::empty:
+    entry_point = ((InterpreterGenerator*) this)->generate_empty_entry();
+    break;
+
+  case Interpreter::accessor:
+    entry_point = ((InterpreterGenerator*) this)->generate_accessor_entry();
+    break;
+
+  case Interpreter::abstract:
+    entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry();
+    break;
+
+  case Interpreter::method_handle:
+    entry_point = ((InterpreterGenerator*) this)->generate_method_handle_entry();
+    break;
+
+  case Interpreter::java_lang_math_sin:
+  case Interpreter::java_lang_math_cos:
+  case Interpreter::java_lang_math_tan:
+  case Interpreter::java_lang_math_abs:
+  case Interpreter::java_lang_math_log:
+  case Interpreter::java_lang_math_log10:
+  case Interpreter::java_lang_math_sqrt:
+    entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind);
+    break;
+
+  default:
+    ShouldNotReachHere();
+  }
+
+  if (entry_point == NULL)
+    entry_point = ((InterpreterGenerator*) this)->generate_normal_entry(false);
+
+  return entry_point;
+}
+
+InterpreterGenerator::InterpreterGenerator(StubQueue* code)
+ : CppInterpreterGenerator(code) {
+   generate_all();
+}
+
+// Deoptimization helpers
+
+InterpreterFrame *InterpreterFrame::build(ZeroStack* stack, int size) {
+  int size_in_words = size >> LogBytesPerWord;
+  assert(size_in_words * wordSize == size, "unaligned");
+  assert(size_in_words >= header_words, "too small");
+
+  if (size_in_words > stack->available_words()) {
+    Unimplemented();
+  }
+
+  stack->push(0); // next_frame, filled in later
+  intptr_t *fp = stack->sp();
+  assert(fp - stack->sp() == next_frame_off, "should be");
+
+  stack->push(INTERPRETER_FRAME);
+  assert(fp - stack->sp() == frame_type_off, "should be");
+
+  interpreterState istate =
+    (interpreterState) stack->alloc(sizeof(BytecodeInterpreter));
+  assert(fp - stack->sp() == istate_off, "should be");
+  istate->set_self_link(NULL); // mark invalid
+
+  stack->alloc((size_in_words - header_words) * wordSize);
+
+  return (InterpreterFrame *) fp;
+}
+
+int AbstractInterpreter::layout_activation(methodOop method,
+                                           int       tempcount,
+                                           int       popframe_extra_args,
+                                           int       moncount,
+                                           int       callee_param_count,
+                                           int       callee_locals,
+                                           frame*    caller,
+                                           frame*    interpreter_frame,
+                                           bool      is_top_frame) {
+  assert(popframe_extra_args == 0, "what to do?");
+  assert(!is_top_frame || (!callee_locals && !callee_param_count),
+         "top frame should have no caller")
+
+  // This code must exactly match what InterpreterFrame::build
+  // does (the full InterpreterFrame::build, that is, not the
+  // one that creates empty frames for the deoptimizer).
+  //
+  // If interpreter_frame is not NULL then it will be filled in.
+  // It's size is determined by a previous call to this method,
+  // so it should be correct.
+  //
+  // Note that tempcount is the current size of the expression
+  // stack.  For top most frames we will allocate a full sized
+  // expression stack and not the trimmed version that non-top
+  // frames have.
+
+  int header_words        = InterpreterFrame::header_words;
+  int monitor_words       = moncount * frame::interpreter_frame_monitor_size();
+  int stack_words         = is_top_frame ? method->max_stack() : tempcount;
+  int callee_extra_locals = callee_locals - callee_param_count;
+
+  if (interpreter_frame) {
+    intptr_t *locals        = interpreter_frame->sp() + method->max_locals();
+    interpreterState istate = interpreter_frame->get_interpreterState();
+    intptr_t *monitor_base  = (intptr_t*) istate;
+    intptr_t *stack_base    = monitor_base - monitor_words;
+    intptr_t *stack         = stack_base - tempcount - 1;
+
+    BytecodeInterpreter::layout_interpreterState(istate,
+                                                 caller,
+                                                 NULL,
+                                                 method,
+                                                 locals,
+                                                 stack,
+                                                 stack_base,
+                                                 monitor_base,
+                                                 NULL,
+                                                 is_top_frame);
+  }
+  return header_words + monitor_words + stack_words + callee_extra_locals;
+}
+
+void BytecodeInterpreter::layout_interpreterState(interpreterState istate,
+                                                  frame*    caller,
+                                                  frame*    current,
+                                                  methodOop method,
+                                                  intptr_t* locals,
+                                                  intptr_t* stack,
+                                                  intptr_t* stack_base,
+                                                  intptr_t* monitor_base,
+                                                  intptr_t* frame_bottom,
+                                                  bool      is_top_frame) {
+  istate->set_locals(locals);
+  istate->set_method(method);
+  istate->set_self_link(istate);
+  istate->set_prev_link(NULL);
+  // thread will be set by a hacky repurposing of frame::patch_pc()
+  // bcp will be set by vframeArrayElement::unpack_on_stack()
+  istate->set_constants(method->constants()->cache());
+  istate->set_msg(BytecodeInterpreter::method_resume);
+  istate->set_bcp_advance(0);
+  istate->set_oop_temp(NULL);
+  istate->set_mdx(NULL);
+  if (caller->is_interpreted_frame()) {
+    interpreterState prev = caller->get_interpreterState();
+    prev->set_callee(method);
+    if (*prev->bcp() == Bytecodes::_invokeinterface)
+      prev->set_bcp_advance(5);
+    else
+      prev->set_bcp_advance(3);
+  }
+  istate->set_callee(NULL);
+  istate->set_monitor_base((BasicObjectLock *) monitor_base);
+  istate->set_stack_base(stack_base);
+  istate->set_stack(stack);
+  istate->set_stack_limit(stack_base - method->max_stack() - 1);
+}
+
+address CppInterpreter::return_entry(TosState state, int length) {
+  ShouldNotCallThis();
+}
+
+address CppInterpreter::deopt_entry(TosState state, int length) {
+  return NULL;
+}
+
+// Helper for (runtime) stack overflow checks
+
+int AbstractInterpreter::size_top_interpreter_activation(methodOop method) {
+  return 0;
+}
+
+// Helper for figuring out if frames are interpreter frames
+
+bool CppInterpreter::contains(address pc) {
+#ifdef PRODUCT
+  ShouldNotCallThis();
+#else
+  return false; // make frame::print_value_on work
+#endif // !PRODUCT
+}
+
+// Result handlers and convertors
+
+address CppInterpreterGenerator::generate_result_handler_for(
+    BasicType type) {
+  assembler()->advance(1);
+  return ShouldNotCallThisStub();
+}
+
+address CppInterpreterGenerator::generate_tosca_to_stack_converter(
+    BasicType type) {
+  assembler()->advance(1);
+  return ShouldNotCallThisStub();
+}
+
+address CppInterpreterGenerator::generate_stack_to_stack_converter(
+    BasicType type) {
+  assembler()->advance(1);
+  return ShouldNotCallThisStub();
+}
+
+address CppInterpreterGenerator::generate_stack_to_native_abi_converter(
+    BasicType type) {
+  assembler()->advance(1);
+  return ShouldNotCallThisStub();
+}
+
+#endif // CC_INTERP

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/cppInterpreter_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,43 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007, 2008 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+ protected:
+  // Size of interpreter code
+  const static int InterpreterCodeSize = 6 * K;
+
+ public:
+  // Method entries
+  static void normal_entry(methodOop method, intptr_t UNUSED, TRAPS);
+  static void native_entry(methodOop method, intptr_t UNUSED, TRAPS);
+  static void accessor_entry(methodOop method, intptr_t UNUSED, TRAPS);
+  static void empty_entry(methodOop method, intptr_t UNUSED, TRAPS);
+
+ public:
+  // Main loop of normal_entry
+  static void main_loop(int recurse, TRAPS);
+
+ private:
+  // Stack overflow checks
+  static bool stack_overflow_imminent(JavaThread *thread);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/debug_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_debug_zero.cpp.incl"
+
+void pd_ps(frame f) {
+  ShouldNotCallThis();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/depChecker_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,26 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// This file is intentionally empty

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/depChecker_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,26 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// This file is intentionally empty

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/disassembler_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,26 @@
+/*
+ * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// This file is intentionally empty

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/disassembler_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2003 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// The disassembler prints out zero code annotated
+// with Java specific information.
+
+  static int pd_instruction_alignment() {
+    ShouldNotCallThis();
+  }
+
+  static const char* pd_cpu_opts() {
+    ShouldNotCallThis();
+  }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/dump_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2004-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_dump_zero.cpp.incl"
+
+void CompactingPermGenGen::generate_vtable_methods(void** vtbl_list,
+                                                   void** vtable,
+                                                   char** md_top,
+                                                   char*  md_end,
+                                                   char** mc_top,
+                                                   char*  mc_end) {
+  ShouldNotCallThis();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/entryFrame_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// |  ...               |
+// +--------------------+  ------------------
+// | parameter n-1      |       low addresses
+// |  ...               |
+// | parameter 0        |
+// | call_wrapper       |
+// | frame_type         |
+// | next_frame         |      high addresses
+// +--------------------+  ------------------
+// |  ...               |
+
+class EntryFrame : public ZeroFrame {
+ private:
+  EntryFrame() : ZeroFrame() {
+    ShouldNotCallThis();
+  }
+
+ protected:
+  enum Layout {
+    call_wrapper_off = jf_header_words,
+    header_words
+  };
+
+ public:
+  static EntryFrame *build(ZeroStack*       stack,
+                           const intptr_t*  parameters,
+                           int              parameter_words,
+                           JavaCallWrapper* call_wrapper);
+ public:
+  JavaCallWrapper *call_wrapper() const {
+    return (JavaCallWrapper *) value_of_word(call_wrapper_off);
+  }
+
+ public:
+  void identify_word(int   frame_index,
+                     int   offset,
+                     char* fieldbuf,
+                     char* valuebuf,
+                     int   buflen) const;
+};

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/entry_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008, 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+class ZeroEntry {
+ public:
+  ZeroEntry() {
+    ShouldNotCallThis();
+  }
+
+ private:
+  address _entry_point;
+
+ public:
+  address entry_point() const {
+    return _entry_point;
+  }
+  void set_entry_point(address entry_point) {
+    _entry_point = entry_point;
+  }
+
+ private:
+  typedef void (*NormalEntryFunc)(methodOop method,
+                                  intptr_t  base_pc,
+                                  TRAPS);
+  typedef void (*OSREntryFunc)(methodOop method,
+                               address   osr_buf,
+                               intptr_t  base_pc,
+                               TRAPS);
+
+ public:
+  void invoke(methodOop method, TRAPS) const {
+    ((NormalEntryFunc) entry_point())(method, (intptr_t) this, THREAD);
+  }
+  void invoke_osr(methodOop method, address osr_buf, TRAPS) const {
+    ((OSREntryFunc) entry_point())(method, osr_buf, (intptr_t) this, THREAD);
+  }
+
+ public:
+  static ByteSize entry_point_offset() {
+    return byte_offset_of(ZeroEntry, _entry_point);
+  }
+};

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/fakeStubFrame_zero.hpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2008 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+// |  ...               |
+// +--------------------+  ------------------
+// | frame_type         |       low addresses
+// | next_frame         |      high addresses
+// +--------------------+  ------------------
+// |  ...               |
+
+class FakeStubFrame : public ZeroFrame {
+ private:
+  FakeStubFrame() : ZeroFrame() {
+    ShouldNotCallThis();
+  }
+
+ protected:
+  enum Layout {
+    header_words = jf_header_words
+  };
+
+ public:
+  static FakeStubFrame *build(ZeroStack* stack);
+
+ public:
+  void identify_word(int   frame_index,
+                     int   offset,
+                     char* fieldbuf,
+                     char* valuebuf,
+                     int   buflen) const {}
+};

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cpu/zero/vm/frame_zero.cpp	Tue Oct 13 12:04:21 2009 -0700
@@ -0,0 +1,414 @@
+/*
+ * Copyright 2003-2007 Sun Microsystems, Inc.  All Rights Reserved.
+ * Copyright 2007, 2008, 2009 Red Hat, Inc.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+#include "incls/_precompiled.incl"
+#include "incls/_frame_zero.cpp.incl"
+
+#ifdef ASSERT
+void RegisterMap::check_location_valid() {
+  ShouldNotCallThis();
+}
+#endif
+
+bool frame::is_interpreted_frame() const {
+  return zeroframe()->is_interpreter_frame();
+}
+
+bool frame::is_fake_stub_frame() const {
+  return zeroframe()->is_fake_stub_frame();
+}
+
+frame frame::sender_for_entry_frame(RegisterMap *map) const {
+  assert(map != NULL, "map must be set");
+  assert(!entry_frame_is_first(), "next Java fp must be non zero");
+  assert(entry_frame_call_wrapper()->anchor()->last_Java_sp() == sender_sp(),
+         "sender should be next Java frame");
+  map->clear();
+  assert(map->include_argument_oops(), "should be set by clear");
+  return frame(sender_sp(), sp() + 1);
+}
+
+frame frame::sender_for_interpreter_frame(RegisterMap *map) const {
+  return frame(sender_sp(), sp() + 1);
+}
+
+frame frame::sender_for_compiled_frame(RegisterMap *map) const {
+  return frame(sender_sp(), sp() + 1);
+}
+
+frame frame::sender_for_fake_stub_frame(RegisterMap *map) const {
+  return frame(sender_sp(), sp() + 1);
+}
+
+frame frame::sender(RegisterMap* map) const {
+  // Default is not to follow arguments; the various
+  // sender_for_xxx methods update this accordingly.
+  map->set_include_argument_oops(false);
+
+  if (is_entry_frame())
+    return sender_for_entry_frame(map);
+
+  if (is_interpreted_frame())
+    return sender_for_interpreter_frame(map);
+
+  if (is_compiled_frame())
+    return sender_for_compiled_frame(map);
+
+  if (is_fake_stub_frame())
+    return sender_for_fake_stub_frame(map);
+
+  ShouldNotReachHere();
+}
+
+#ifdef CC_INTERP
+BasicObjectLock* frame::interpreter_frame_monitor_begin() const {
+  return get_interpreterState()->monitor_base();
+}
+
+BasicObjectLock* frame::interpreter_frame_monitor_end() const {
+  return (BasicObjectLock*) get_interpreterState()->stack_base();
+}
+#endif // CC_INTERP
+
+void frame::patch_pc(Thread* thread, address pc) {
+  // We borrow this call to set the thread pointer in the interpreter
+  // state; the hook to set up deoptimized frames isn't supplied it.
+  assert(pc == NULL, "should be");
+  get_interpreterState()->set_thread((JavaThread *) thread);
+}
+
+bool frame::safe_for_sender(JavaThread *thread) {
+  ShouldNotCallThis();
+}
+
+void frame::pd_gc_epilog() {
+}
+
+bool frame::is_interpreted_frame_valid(JavaThread *thread) const {
+  ShouldNotCallThis();
+}
+
+BasicType frame::interpreter_frame_result(oop* oop_result,
+                                          jvalue* value_result) {
+  assert(is_interpreted_frame(), "interpreted frame expected");
+  methodOop method = interpreter_frame_method();
+  BasicType type = method->result_type();
+  intptr_t* tos_addr = (intptr_t *) interpreter_frame_tos_address();
+  oop obj;
+
+  switch (type) {
+  case T_VOID:
+    break;
+  case T_BOOLEAN:
+    value_result->z = *(jboolean *) tos_addr;
+    break;
+  case T_BYTE:
+    value_result->b = *(jbyte *) tos_addr;
+    break;
+  case T_CHAR:
+    value_result->c = *(jchar *) tos_addr;
+    break;
+  case T_SHORT:
+    value_result->s = *(jshort *) tos_addr;
+    break;
+  case T_INT:
+    value_result->i = *(jint *) tos_addr;
+    break;
+  case T_LONG:
+    value_result->j = *(jlong *) tos_addr;
+    break;
+  case T_FLOAT:
+    value_result->f = *(jfloat *) tos_addr;
+    break;
+  case T_DOUBLE:
+    value_result->d = *(jdouble *) tos_addr;
+    break;
+
+  case T_OBJECT:
+  case T_ARRAY:
+    if (method->is_native()) {
+      obj = get_interpreterState()->oop_temp();
+    }
+    else {
+      oop* obj_p = (oop *) tos_addr;
+      obj = (obj_p == NULL) ? (oop) NULL : *obj_p;
+    }
+    assert(obj == NULL || Universe::heap()->is_in(obj), "sanity check");
+    *oop_result = obj;
+    break;
+
+  default:
+    ShouldNotReachHere();
+  }
+
+  return type;
+}
+
+int frame::frame_size(RegisterMap* map) const {
+#ifdef PRODUCT
+  ShouldNotCallThis();
+#else
+  return 0; // make javaVFrame::print_value work
+#endif // PRODUCT
+}
+
+intptr_t* frame::interpreter_frame_tos_at(jint offset) const {
+  int index = (Interpreter::expr_offset_in_bytes(offset) / wordSize);
+  return &interpreter_frame_tos_address()[index];
+}
+
+void frame::zero_print_on_error(int           frame_index,
+                                outputStream* st,
+                                char*         buf,
+                                int           buflen) const {
+  // Divide the buffer between the field and the value
+  buflen >>= 1;
+  char *fieldbuf = buf;
+  char *valuebuf = buf + buflen;
+
+  // Print each word of the frame
+  for (intptr_t *addr = fp(); addr <= sp(); addr++) {
+    int offset = sp() - addr;
+
+    // Fill in default values, then try and improve them
+    snprintf(fieldbuf, buflen, "word[%d]", offset);
+    snprintf(valuebuf, buflen, PTR_FORMAT, *addr);
+    zeroframe()->identify_word(frame_index, offset, fieldbuf, valuebuf, buflen);
+    fieldbuf[buflen - 1] = '\0';
+    valuebuf[buflen - 1] = '\0';
+
+    // Print the result
+    st->print_cr(" " PTR_FORMAT ": %-21s = %s", addr, fieldbuf, valuebuf);
+  }
+}
+
+void ZeroFrame::identify_word(int   frame_index,
+                              int   offset,
+                              char* fieldbuf,
+                              char* valuebuf,
+                              int   buflen) const {
+  switch (offset) {
+  case next_frame_off:
+    strncpy(fieldbuf, "next_frame", buflen);
+    break;
+
+  case frame_type_off:
+    strncpy(fieldbuf, "frame_type", buflen);
+    if (is_entry_frame())
+      strncpy(valuebuf, "ENTRY_FRAME", buflen);
+    else if (is_interpreter_frame())
+      strncpy(valuebuf, "INTERPRETER_FRAME", buflen);
+    else if (is_shark_frame())
+      strncpy(valuebuf, "SHARK_FRAME", buflen);
+    else if (is_fake_stub_frame())
+      strncpy(valuebuf, "FAKE_STUB_FRAME", buflen);
+    break;
+
+  default:
+    if (is_entry_frame()) {
+      as_entry_frame()->identify_word(
+        frame_index, offset, fieldbuf, valuebuf, buflen);
+    }
+    else if (is_interpreter_frame()) {
+      as_interpreter_frame()->identify_word(
+        frame_index, offset, fieldbuf, valuebuf, buflen);
+    }
+    else if (is_shark_frame()) {
+      as_shark_frame()->identify_word(
+        frame_index, offset, fieldbuf, valuebuf, buflen);
+    }
+    else if (is_fake_stub_frame()) {
+      as_fake_stub_frame()->identify_word(
+        frame_index, offset, fieldbuf, valuebuf, buflen);
+    }
+  }
+}
+
+void EntryFrame::identify_word(int   frame_index,
+                               int   offset,
+                               char* fieldbuf,
+                               char* valuebuf,
+                               int   buflen) const {
+  switch (offset) {
+  case call_wrapper_off:
+    strncpy(fieldbuf, "call_wrapper", buflen);
+    break;
+
+  default:
+    snprintf(fieldbuf, buflen, "local[%d]", offset - 3);
+  }
+}
+
+void InterpreterFrame::identify_word(int   frame_index,
+                                     int   offset,
+                                     char* fieldbuf,
+                                     char* valuebuf,
+                                     int   buflen) const {
+  interpreterState istate = interpreter_state();
+  bool is_valid = istate->self_link() == istate;
+  intptr_t *addr = addr_of_word(offset);
+
+  // Fixed part
+  if (addr >= (intptr_t *) istate) {
+    const char *field = istate->name_of_field_at_address((address) addr);
+    if (field) {
+      if (is_valid && !strcmp(field, "_method")) {
+        istate->method()->name_and_sig_as_C_string(valuebuf, buflen);
+      }
+      else if (is_valid && !strcmp(field, "_bcp") && istate->bcp()) {
+        snprintf(valuebuf, buflen, PTR_FORMAT " (bci %d)",
+                 (intptr_t) istate->bcp(),
+                 istate->method()->bci_from(istate->bcp()));
+      }
+      snprintf(fieldbuf, buflen, "%sistate->%s",
+               field[strlen(field) - 1] == ')' ? "(": "", field);
+    }
+    else if (addr == (intptr_t *) istate) {
+      strncpy(fieldbuf, "(vtable for istate)", buflen);
+    }
+    return;
+  }
+
+  // Variable part
+  if (!is_valid)
+    return;
+
+  // JNI stuff
+  if (istate->method()->is_native() && addr < istate->stack_base()) {
+    address hA = istate->method()->signature_handler();
+    if (hA != NULL) {
+      if (hA != (address) InterpreterRuntime::slow_signature_handler) {
+        InterpreterRuntime::SignatureHandler *handler =
+          InterpreterRuntime::SignatureHandler::from_handlerAddr(hA);
+
+        intptr_t *params = istate->stack_base() - handler->argument_count();
+        if (addr >= params) {
+          int param = addr - params;
+          const char *desc = "";
+          if (param == 0)
+            desc = " (JNIEnv)";
+          else if (param == 1) {
+            if (istate->method()->is_static())
+              desc = " (mirror)";
+            else
+              desc = " (this)";
+          }
+          snprintf(fieldbuf, buflen, "parameter[%d]%s", param, desc);
+          return;
+        }
+
+        for (int i = 0; i < handler->argument_count(); i++) {
+          if (params[i] == (intptr_t) addr) {
+            snprintf(fieldbuf, buflen, "unboxed parameter[%d]", i);
+            return;
+          }
+        }
+      }
+    }
+    return;
+  }
+
+  // Monitors and stack
+  identify_vp_word(frame_index, addr,
+                   (intptr_t *) istate->monitor_base(),
+                   istate->stack_base(),
+                   fieldbuf, buflen);
+}
+
+void SharkFrame::identify_word(int   frame_index,
+                               int   offset,
+                               char* fieldbuf,
+                               char* valuebuf,
+                               int   buflen) const {
+  // Fixed part
+  switch (offset) {
+  case pc_off:
+    strncpy(fieldbuf, "pc", buflen);
+    if (method()->is_oop()) {
+      nmethod *code = method()->code();
+      if (code && code->pc_desc_at(pc())) {
+        SimpleScopeDesc ssd(code, pc());
+        snprintf(valuebuf, buflen, PTR_FORMAT " (bci %d)",
+                 (intptr_t) pc(), ssd.bci());
+      }
+    }
+    return;
+
+  case unextended_sp_off:
+    strncpy(fieldbuf, "unextended_sp", buflen);
+    return;
+
+  case method_off:
+    strncpy(fieldbuf, "method", buflen);
+    if (method()->is_oop()) {
+      method()->name_and_sig_as_C_string(valuebuf, buflen);
+    }
+    return;
+
+  case oop_tmp_off:
+    strncpy(fieldbuf, "oop_tmp", buflen);
+    return;
+  }
+
+  // Variable part
+  if (method()->is_oop()) {
+    identify_vp_word(frame_index, addr_of_word(offset),
+                     addr_of_word(header_words + 1),
+                     unextended_sp() + method()->max_stack(),
+                     fieldbuf, buflen);
+  }
+}
+
+void ZeroFrame::identify_vp_word(int       frame_index,
+                                 intptr_t* addr,
+                                 intptr_t* monitor_base,
+                                 intptr_t* stack_base,
+                                 char*     fieldbuf,
+                                 int       buflen) const {
+  // Monitors
+  if (addr >= stack_base && addr < monitor_base) {
+    int monitor_size = frame::interpreter_frame_monitor_size();
+    int last_index = (monitor_base - stack_base) / monitor_size - 1;
+    int index = last_index - (addr - stack_base) / monitor_size;
+    intptr_t monitor = (intptr_t) (
+      (BasicObjectLock *) monitor_base - 1 - index);
+    intptr_t offset = (intptr_t) addr - monitor;
+
+    if (offset == BasicObjectLock::obj_offset_in_bytes())
+      snprintf(fieldbuf, buflen, "monitor[%d]->_obj", index);
+    else if (offset ==  BasicObjectLock::lock_offset_in_bytes())
+      snprintf(fieldbuf, buflen, "monitor[%d]->_lock", index);
+
+    return;
+  }
+
+  // Expression stack
+  if (addr < stack_base) {
+    snprintf(fieldbuf, buflen, "%s[%d]",
+             frame_index == 0 ? "stack_word" : "local",
+             (int) (stack_base - addr - 1));
+    return;
+  }
+}