Attachment 174808 Details for Bug 212709 – Patch to add Serviceability Agent support for PowerPC64

Patch to add Serviceability Agent support for PowerPC64

patch-hotspot_agent (text/plain), 90.44 KB, created by Curtis Hamilton on 2016-09-15 20:31:46 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Curtis Hamilton

Created: 2016-09-15 20:31:46 UTC

Size: 90.44 KB

patch

obsolete

>--- ./common/autoconf/jdk-options.m4.orig
>+++ ./common/autoconf/jdk-options.m4
>@@ -159,7 +159,7 @@
>     INCLUDE_SA=false
>   fi
>   if test "x$VAR_CPU" = xppc64 ; then
>-    INCLUDE_SA=false
>+    INCLUDE_SA=true
>   fi
>   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
>     INCLUDE_SA=false
>--- ./hotspot/agent/make/Makefile
>+++ ./hotspot/agent/make/Makefile
>@@ -50,6 +50,7 @@
> sun.jvm.hotspot.debugger.amd64 \
> sun.jvm.hotspot.debugger.bsd \
> sun.jvm.hotspot.debugger.bsd.amd64 \
>+sun.jvm.hotspot.debugger.bsd.ppc64 \
> sun.jvm.hotspot.debugger.bsd.x86 \
> sun.jvm.hotspot.debugger.cdbg \
> sun.jvm.hotspot.debugger.cdbg.basic \
>@@ -58,15 +59,19 @@
> sun.jvm.hotspot.debugger.dummy \
> sun.jvm.hotspot.debugger.linux \
> sun.jvm.hotspot.debugger.linux.amd64 \
>+sun.jvm.hotspot.debugger.linux.ppc64 \
> sun.jvm.hotspot.debugger.linux.x86 \
> sun.jvm.hotspot.debugger.posix \
> sun.jvm.hotspot.debugger.posix.elf \
>+sun.jvm.hotspot.debugger.ppc64 \
> sun.jvm.hotspot.debugger.proc \
> sun.jvm.hotspot.debugger.proc.amd64 \
>+sun.jvm.hotspot.debugger.proc.ppc64 \
> sun.jvm.hotspot.debugger.proc.sparc \
> sun.jvm.hotspot.debugger.proc.x86 \
> sun.jvm.hotspot.debugger.remote \
> sun.jvm.hotspot.debugger.remote.amd64 \
>+sun.jvm.hotspot.debugger.remote.ppc64 \
> sun.jvm.hotspot.debugger.remote.sparc \
> sun.jvm.hotspot.debugger.remote.x86 \
> sun.jvm.hotspot.debugger.sparc \
>@@ -90,12 +95,15 @@
> sun.jvm.hotspot.runtime.amd64 \
> sun.jvm.hotspot.runtime.bsd \
> sun.jvm.hotspot.runtime.bsd_amd64 \
>+sun.jvm.hotspot.runtime.bsd_ppc64 \
> sun.jvm.hotspot.runtime.bsd_x86 \
> sun.jvm.hotspot.runtime.linux \
> sun.jvm.hotspot.runtime.linux_amd64 \
>+sun.jvm.hotspot.runtime.linux_ppc64 \
> sun.jvm.hotspot.runtime.linux_sparc \
> sun.jvm.hotspot.runtime.linux_x86 \
> sun.jvm.hotspot.runtime.posix \
>+sun.jvm.hotspot.runtime.ppc64 \
> sun.jvm.hotspot.runtime.solaris_amd64 \
> sun.jvm.hotspot.runtime.solaris_sparc \
> sun.jvm.hotspot.runtime.solaris_x86 \
>@@ -135,6 +143,7 @@
> sun/jvm/hotspot/debugger/amd64/*.java \
> sun/jvm/hotspot/debugger/bsd/*.java \
> sun/jvm/hotspot/debugger/bsd/amd64/*.java \
>+sun/jvm/hotspot/debugger/bsd/ppc64/*.java \
> sun/jvm/hotspot/debugger/bsd/x86/*.java \
> sun/jvm/hotspot/debugger/cdbg/*.java \
> sun/jvm/hotspot/debugger/cdbg/basic/*.java \
>@@ -142,15 +151,19 @@
> sun/jvm/hotspot/debugger/cdbg/basic/x86/*.java \
> sun/jvm/hotspot/debugger/dummy/*.java \
> sun/jvm/hotspot/debugger/linux/*.java \
>+sun/jvm/hotspot/debugger/linux/ppc64/*.java \
> sun/jvm/hotspot/debugger/linux/x86/*.java \
> sun/jvm/hotspot/debugger/posix/*.java \
> sun/jvm/hotspot/debugger/posix/elf/*.java \
>+sun/jvm/hotspot/debugger/ppc64/*.java \
> sun/jvm/hotspot/debugger/proc/*.java \
> sun/jvm/hotspot/debugger/proc/amd64/*.java \
>+sun/jvm/hotspot/debugger/proc/ppc64/*.java \
> sun/jvm/hotspot/debugger/proc/sparc/*.java \
> sun/jvm/hotspot/debugger/proc/x86/*.java \
> sun/jvm/hotspot/debugger/remote/*.java \
> sun/jvm/hotspot/debugger/remote/amd64/*.java \
>+sun/jvm/hotspot/debugger/remote/ppc64/*.java \
> sun/jvm/hotspot/debugger/remote/sparc/*.java \
> sun/jvm/hotspot/debugger/remote/x86/*.java \
> sun/jvm/hotspot/debugger/sparc/*.java \
>@@ -171,12 +184,15 @@
> sun/jvm/hotspot/runtime/amd64/*.java \
> sun/jvm/hotspot/runtime/bsd/*.java \
> sun/jvm/hotspot/runtime/bsd_amd64/*.java \
>+sun/jvm/hotspot/runtime/bsd_ppc64/*.java \
> sun/jvm/hotspot/runtime/bsd_x86/*.java \
> sun/jvm/hotspot/runtime/linux/*.java \
> sun/jvm/hotspot/runtime/linux_amd64/*.java \
>+sun/jvm/hotspot/runtime/linux_ppc64/*.java \
> sun/jvm/hotspot/runtime/linux_sparc/*.java \
> sun/jvm/hotspot/runtime/linux_x86/*.java \
> sun/jvm/hotspot/runtime/posix/*.java \
>+sun/jvm/hotspot/runtime/ppc64/*.java \
> sun/jvm/hotspot/runtime/solaris_amd64/*.java \
> sun/jvm/hotspot/runtime/solaris_sparc/*.java \
> sun/jvm/hotspot/runtime/solaris_x86/*.java \
>--- ./hotspot/agent/src/os/bsd/BsdDebuggerLocal.c
>+++ ./hotspot/agent/src/os/bsd/BsdDebuggerLocal.c
>@@ -42,6 +42,10 @@
> #include "sun_jvm_hotspot_debugger_sparc_SPARCThreadContext.h"
> #endif
> 
>+#ifdef ppc64
>+#include "sun_jvm_hotspot_debugger_ppc64_PPC64ThreadContext.h"
>+#endif
>+
> static jfieldID p_ps_prochandle_ID = 0;
> static jfieldID threadList_ID = 0;
> static jfieldID loadObjectList_ID = 0;
>@@ -306,6 +310,9 @@
> #endif
> #if defined(sparc) || defined(sparcv9)
> #define NPRGREG sun_jvm_hotspot_debugger_sparc_SPARCThreadContext_NPRGREG
>+#endif
>+#ifdef ppc64
>+#define NPRGREG sun_jvm_hotspot_debugger_ppc64_PPC64ThreadContext_NPRGREG
> #endif
> 
>   array = (*env)->NewLongArray(env, NPRGREG);
>@@ -407,6 +414,46 @@
>   regs[REG_INDEX(R_O7)]  = gregs.u_regs[14];
> #endif /* sparc */
> 
>+#if defined(ppc64) || defined(ppc64le)
>+#define REG_INDEX(reg) sun_jvm_hotspot_debugger_ppc64_PPC64ThreadContext_##reg
>+
>+  regs[REG_INDEX(LR)] = gregs.lr;
>+  regs[REG_INDEX(PC)] = gregs.pc;
>+  regs[REG_INDEX(R0)]  = gregs.fixreg[0];
>+  regs[REG_INDEX(R1)]  = gregs.fixreg[1];
>+  regs[REG_INDEX(R2)]  = gregs.fixreg[2];
>+  regs[REG_INDEX(R3)]  = gregs.fixreg[3];
>+  regs[REG_INDEX(R4)]  = gregs.fixreg[4];
>+  regs[REG_INDEX(R5)]  = gregs.fixreg[5];
>+  regs[REG_INDEX(R6)]  = gregs.fixreg[6];
>+  regs[REG_INDEX(R7)]  = gregs.fixreg[7];
>+  regs[REG_INDEX(R8)]  = gregs.fixreg[8];
>+  regs[REG_INDEX(R9)]  = gregs.fixreg[9];
>+  regs[REG_INDEX(R10)] = gregs.fixreg[10];
>+  regs[REG_INDEX(R11)] = gregs.fixreg[11];
>+  regs[REG_INDEX(R12)] = gregs.fixreg[12];
>+  regs[REG_INDEX(R13)] = gregs.fixreg[13];
>+  regs[REG_INDEX(R14)] = gregs.fixreg[14];
>+  regs[REG_INDEX(R15)] = gregs.fixreg[15];
>+  regs[REG_INDEX(R16)] = gregs.fixreg[16];
>+  regs[REG_INDEX(R17)] = gregs.fixreg[17];
>+  regs[REG_INDEX(R18)] = gregs.fixreg[18];
>+  regs[REG_INDEX(R19)] = gregs.fixreg[19];
>+  regs[REG_INDEX(R20)] = gregs.fixreg[20];
>+  regs[REG_INDEX(R21)] = gregs.fixreg[21];
>+  regs[REG_INDEX(R22)] = gregs.fixreg[22];
>+  regs[REG_INDEX(R23)] = gregs.fixreg[23];
>+  regs[REG_INDEX(R24)] = gregs.fixreg[24];
>+  regs[REG_INDEX(R25)] = gregs.fixreg[25];
>+  regs[REG_INDEX(R26)] = gregs.fixreg[26];
>+  regs[REG_INDEX(R27)] = gregs.fixreg[27];
>+  regs[REG_INDEX(R28)] = gregs.fixreg[28];
>+  regs[REG_INDEX(R29)] = gregs.fixreg[29];
>+  regs[REG_INDEX(R30)] = gregs.fixreg[30];
>+  regs[REG_INDEX(R31)] = gregs.fixreg[31];
>+
>+#endif
>+ 
>
>   (*env)->ReleaseLongArrayElements(env, array, regs, JNI_COMMIT);
>   return array;
>--- ./hotspot/agent/src/os/bsd/symtab.c
>+++ ./hotspot/agent/src/os/bsd/symtab.c
>@@ -211,6 +211,10 @@
> 
>   // Reading of elf header
>   struct elf_section *scn_cache = NULL;
>+#if defined(ppc64)
>+  struct elf_section *opd_sect = NULL;
>+  ELF_SHDR *opd = NULL;
>+#endif
>   int cnt = 0;
>   ELF_SHDR* shbuf = NULL;
>   ELF_SHDR* cursct = NULL;
>@@ -257,6 +261,14 @@
> 
>     cursct++;
>   }
>+
>+#if defined(ppc64)
>+  opd_sect = find_section_by_name(".opd", fd, &ehdr, scn_cache);
>+  if (opd_sect != NULL && opd_sect->c_data != NULL && opd_sect->c_shdr != NULL) {
>+    // plausibility check
>+    opd = opd_sect->c_shdr;
>+  }
>+#endif
> 
>   if (!symtab_found && dynsym_found)
>      symsection = SHT_DYNSYM;
>@@ -322,6 +334,13 @@
>         symtab->symbols[j].name   = sym_name;
>         symtab->symbols[j].offset = syms->st_value - baseaddr;
>         symtab->symbols[j].size   = syms->st_size;
>+#if defined(ppc64)
>+        if (opd != NULL && *sym_name != '.' &&
>+            (opd->sh_addr <= syms->st_value && syms->st_value <= opd->sh_addr + opd->sh_size))
>+          symtab->symbols[j].offset =
>+            ((ELF_ADDR*)opd_sect->c_data)[(syms->st_value - opd->sh_addr) / sizeof(ELF_ADDR*)] - baseaddr;
>+        else
>+#endif
> 
>         key.data = sym_name;
>         key.size = strlen(sym_name) + 1;
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/HotSpotAgent.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/HotSpotAgent.java
>@@ -33,6 +33,7 @@
> import sun.jvm.hotspot.debugger.JVMDebugger;
> import sun.jvm.hotspot.debugger.MachineDescription;
> import sun.jvm.hotspot.debugger.MachineDescriptionAMD64;
>+import sun.jvm.hotspot.debugger.MachineDescriptionPPC64;
> import sun.jvm.hotspot.debugger.MachineDescriptionIA64;
> import sun.jvm.hotspot.debugger.MachineDescriptionIntelX86;
> import sun.jvm.hotspot.debugger.MachineDescriptionSPARC32Bit;
>@@ -588,6 +589,8 @@
>             machDesc = new MachineDescriptionIA64();
>         } else if (cpu.equals("amd64")) {
>             machDesc = new MachineDescriptionAMD64();
>+        } else if (cpu.equals("ppc64")) {
>+            machDesc = new MachineDescriptionPPC64();
>         } else if (cpu.equals("sparc")) {
>             if (LinuxDebuggerLocal.getAddressSize()==8) {
>                     machDesc = new MachineDescriptionSPARC64Bit();
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionPPC64.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionPPC64.java
>@@ -0,0 +1,43 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger;
>+
>+public class MachineDescriptionPPC64 extends MachineDescriptionTwosComplement implements MachineDescription {
>+  public long getAddressSize() {
>+    return 8;
>+  }
>+
>+  public boolean isLP64() {
>+    return true;
>+  }
>+
>+  public boolean isBigEndian() {
>+    String endian = System.getProperty("sun.cpu.endian");
>+    if (endian.equals("big"))
>+      return true;
>+    else
>+      return false;
>+  }
>+}
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdCDebugger.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdCDebugger.java
>@@ -30,8 +30,10 @@
> import sun.jvm.hotspot.debugger.cdbg.*;
> import sun.jvm.hotspot.debugger.x86.*;
> import sun.jvm.hotspot.debugger.amd64.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
> import sun.jvm.hotspot.debugger.bsd.x86.*;
> import sun.jvm.hotspot.debugger.bsd.amd64.*;
>+import sun.jvm.hotspot.debugger.bsd.ppc64.*;
> import sun.jvm.hotspot.utilities.*;
> 
> class BsdCDebugger implements CDebugger {
>@@ -97,6 +99,13 @@
>        Address pc  = context.getRegisterAsAddress(AMD64ThreadContext.RIP);
>        if (pc == null) return null;
>        return new BsdAMD64CFrame(dbg, rbp, pc);
>+    }  else if (cpu.equals("ppc64")) {
>+        PPC64ThreadContext context = (PPC64ThreadContext) thread.getContext();
>+        Address sp = context.getRegisterAsAddress(PPC64ThreadContext.SP);
>+        if (sp == null) return null;
>+        Address pc  = context.getRegisterAsAddress(PPC64ThreadContext.PC);
>+        if (pc == null) return null;
>+        return new BsdPPC64CFrame(dbg, sp, pc, BsdDebuggerLocal.getAddressSize());
>     } else {
>        throw new DebuggerException(cpu + " is not yet supported");
>     }
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdThreadContextFactory.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdThreadContextFactory.java
>@@ -27,6 +27,7 @@
> import sun.jvm.hotspot.debugger.*;
> import sun.jvm.hotspot.debugger.bsd.amd64.*;
> import sun.jvm.hotspot.debugger.bsd.x86.*;
>+import sun.jvm.hotspot.debugger.bsd.ppc64.*;
> 
> class BsdThreadContextFactory {
>    static ThreadContext createThreadContext(BsdDebugger dbg) {
>@@ -35,6 +36,8 @@
>          return new BsdX86ThreadContext(dbg);
>       } else if (cpu.equals("amd64") || cpu.equals("x86_64")) {
>          return new BsdAMD64ThreadContext(dbg);
>+      }  else if (cpu.equals("ppc64")) {
>+          return new BsdPPC64ThreadContext(dbg);
>       } else {
>          throw new RuntimeException("cpu " + cpu + " is not yet supported");
>       }
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/ppc64/LinuxPPC64CFrame.java
>@@ -0,0 +1,79 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.linux.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.linux.*;
>+import sun.jvm.hotspot.debugger.cdbg.*;
>+import sun.jvm.hotspot.debugger.cdbg.basic.*;
>+
>+final public class LinuxPPC64CFrame extends BasicCFrame {
>+  // package/class internals only
>+
>+  public LinuxPPC64CFrame(LinuxDebugger dbg, Address sp, Address pc, int address_size) {
>+    super(dbg.getCDebugger());
>+    this.sp = sp;
>+    this.pc = pc;
>+    this.dbg = dbg;
>+    this.address_size=address_size;
>+  }
>+
>+  // override base class impl to avoid ELF parsing
>+  public ClosestSymbol closestSymbolToPC() {
>+    // try native lookup in debugger.
>+    return dbg.lookup(dbg.getAddressValue(pc()));
>+  }
>+
>+  public Address pc() {
>+    return     pc;
>+  }
>+
>+  public Address localVariableBase() {
>+    return sp;
>+  }
>+
>+  public CFrame sender(ThreadProxy thread) {
>+    if (sp == null) {
>+      return null;
>+    }
>+
>+    Address nextSP = sp.getAddressAt(0);
>+    if (nextSP == null) {
>+      return null;
>+    }
>+    Address nextPC  = sp.getAddressAt(2 * address_size);
>+    if (nextPC == null) {
>+      return null;
>+    }
>+    return new LinuxPPC64CFrame(dbg, nextSP, nextPC, address_size);
>+  }
>+
>+  public static int PPC64_STACK_BIAS = 0;
>+  private static int address_size;
>+  private Address pc;
>+  private Address sp;
>+  private LinuxDebugger dbg;
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/ppc64/BsdPPC64CFrame.java
>@@ -0,0 +1,79 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.bsd.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.bsd.*;
>+import sun.jvm.hotspot.debugger.cdbg.*;
>+import sun.jvm.hotspot.debugger.cdbg.basic.*;
>+
>+final public class BsdPPC64CFrame extends BasicCFrame {
>+  // package/class internals only
>+
>+  public BsdPPC64CFrame(BsdDebugger dbg, Address sp, Address pc, int address_size) {
>+    super(dbg.getCDebugger());
>+    this.sp = sp;
>+    this.pc = pc;
>+    this.dbg = dbg;
>+    this.address_size=address_size;
>+  }
>+
>+  // override base class impl to avoid ELF parsing
>+  public ClosestSymbol closestSymbolToPC() {
>+    // try native lookup in debugger.
>+    return dbg.lookup(dbg.getAddressValue(pc()));
>+  }
>+
>+  public Address pc() {
>+    return     pc;
>+  }
>+
>+  public Address localVariableBase() {
>+    return sp;
>+  }
>+
>+  public CFrame sender(ThreadProxy thread) {
>+    if (sp == null) {
>+      return null;
>+    }
>+
>+    Address nextSP = sp.getAddressAt(0);
>+    if (nextSP == null) {
>+      return null;
>+    }
>+    Address nextPC  = sp.getAddressAt(2 * address_size);
>+    if (nextPC == null) {
>+      return null;
>+    }
>+    return new BsdPPC64CFrame(dbg, nextSP, nextPC, address_size);
>+  }
>+
>+  public static int PPC64_STACK_BIAS = 0;
>+  private static int address_size;
>+  private Address pc;
>+  private Address sp;
>+  private BsdDebugger dbg;
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/ppc64/LinuxPPC64ThreadContext.java
>@@ -0,0 +1,46 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.linux.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.linux.*;
>+
>+public class LinuxPPC64ThreadContext extends PPC64ThreadContext {
>+  private LinuxDebugger debugger;
>+
>+  public LinuxPPC64ThreadContext(LinuxDebugger debugger) {
>+    super();
>+    this.debugger = debugger;
>+  }
>+
>+  public void setRegisterAsAddress(int index, Address value) {
>+    setRegister(index, debugger.getAddressValue(value));
>+  }
>+
>+  public Address getRegisterAsAddress(int index) {
>+    return debugger.newAddress(getRegister(index));
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/ppc64/BsdPPC64ThreadContext.java
>@@ -0,0 +1,46 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.bsd.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.bsd.*;
>+
>+public class BsdPPC64ThreadContext extends PPC64ThreadContext {
>+  private BsdDebugger debugger;
>+
>+  public BsdPPC64ThreadContext(BsdDebugger debugger) {
>+    super();
>+    this.debugger = debugger;
>+  }
>+
>+  public void setRegisterAsAddress(int index, Address value) {
>+    setRegister(index, debugger.getAddressValue(value));
>+  }
>+
>+  public Address getRegisterAsAddress(int index) {
>+    return debugger.newAddress(getRegister(index));
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/ppc64/PPC64ThreadContext.java
>@@ -0,0 +1,123 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.cdbg.*;
>+
>+/** Specifies the thread context on ppc64 platforms; only a sub-portion
>+ * of the context is guaranteed to be present on all operating
>+ * systems. */
>+
>+public abstract class PPC64ThreadContext implements ThreadContext {
>+
>+  // NOTE: The indices for the various registers must be maintained as
>+  // listed across various operating systems. However, only a small
>+  // subset of the registers' values are guaranteed to be present (and
>+  // must be present for the SA's stack walking to work).
>+
>+  public static final int R31 = 0;
>+  public static final int R30 = 1;
>+  public static final int R29 = 2;
>+  public static final int R28 = 3;
>+  public static final int R27 = 4;
>+  public static final int R26 = 5;
>+  public static final int R25  = 6;
>+  public static final int R24  = 7;
>+  public static final int R23 = 8;
>+  public static final int R22 = 9;
>+  public static final int R21 = 10;
>+  public static final int R20 = 11;
>+  public static final int R19 = 12;
>+  public static final int R18 = 13;
>+  public static final int R17 = 14;
>+  public static final int R16 = 15;
>+  public static final int R15 = 16;
>+  public static final int R14 = 17;
>+  public static final int R13 = 18;
>+  public static final int R12 = 19;
>+  public static final int R11 = 20;
>+  public static final int R10 = 21;
>+  public static final int R9 = 22;
>+  public static final int R8 = 23;
>+  public static final int R7 = 24;
>+  public static final int R6 = 25;
>+  public static final int R5 = 26;
>+  public static final int R4 = 27;
>+  public static final int R3 = 28;
>+  public static final int R2 = 29;
>+  public static final int R1 = 30;
>+  public static final int R0 = 31;
>+  public static final int NIP = 32;
>+  public static final int LR = 33;
>+
>+  public static final int NPRGREG = 34;
>+
>+  private static final String[] regNames = {
>+    "r31", "r30", "r29", "r28", "r27", "r26", "r25", "r24",
>+    "r23", "r22", "r21", "r20", "r19", "r18", "r17", "r16",
>+    "r15", "r14", "r13", "r12", "r11", "r10", "r9",  "r8",
>+    "r7",  "r6",  "r5",  "r4",  "r3",   "r2", "r1",  "r0",
>+    "nip", "link"
>+  };
>+
>+  public static final int PC = NIP;
>+  public static final int SP = R1;
>+
>+  private long[] data;
>+
>+  public PPC64ThreadContext() {
>+    data = new long[NPRGREG];
>+  }
>+
>+  public int getNumRegisters() {
>+    return NPRGREG;
>+  }
>+
>+  public String getRegisterName(int index) {
>+    return regNames[index];
>+  }
>+
>+  public void setRegister(int index, long value) {
>+    data[index] = value;
>+  }
>+
>+  public long getRegister(int index) {
>+    return data[index];
>+  }
>+
>+  public CFrame getTopFrame(Debugger dbg) {
>+    return null;
>+  }
>+
>+  /** This can't be implemented in this class since we would have to
>+   * tie the implementation to, for example, the debugging system */
>+  public abstract void setRegisterAsAddress(int index, Address value);
>+
>+  /** This can't be implemented in this class since we would have to
>+   * tie the implementation to, for example, the debugging system */
>+  public abstract Address getRegisterAsAddress(int index);
>+
>+}
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebuggerLocal.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebuggerLocal.java
>@@ -32,7 +32,9 @@
> import sun.jvm.hotspot.debugger.cdbg.*;
> import sun.jvm.hotspot.debugger.proc.amd64.*;
> import sun.jvm.hotspot.debugger.proc.sparc.*;
>+import sun.jvm.hotspot.debugger.proc.ppc64.*;
> import sun.jvm.hotspot.debugger.proc.x86.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
> import sun.jvm.hotspot.debugger.amd64.*;
> import sun.jvm.hotspot.debugger.sparc.*;
> import sun.jvm.hotspot.debugger.x86.*;
>@@ -86,6 +88,10 @@
>             threadFactory = new ProcAMD64ThreadFactory(this);
>             pcRegIndex = AMD64ThreadContext.RIP;
>             fpRegIndex = AMD64ThreadContext.RBP;
>+        } else if (cpu.equals("ppc64")) {
>+            threadFactory = new ProcPPC64ThreadFactory(this);
>+            pcRegIndex = PPC64ThreadContext.PC;
>+            fpRegIndex = PPC64ThreadContext.SP;
>         } else {
>           try {
>             Class tfc = Class.forName("sun.jvm.hotspot.debugger.proc." +
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ppc64/ProcPPC64Thread.java
>@@ -0,0 +1,86 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.proc.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.proc.*;
>+import sun.jvm.hotspot.utilities.*;
>+
>+public class ProcPPC64Thread implements ThreadProxy {
>+  private ProcDebugger debugger;
>+  private int         id;
>+
>+  public ProcPPC64Thread(ProcDebugger debugger, Address addr) {
>+    this.debugger = debugger;
>+
>+    // FIXME: the size here should be configurable. However, making it
>+    // so would produce a dependency on the "types" package from the
>+    // debugger package, which is not desired.
>+    this.id       = (int) addr.getCIntegerAt(0, 4, true);
>+  }
>+
>+  public ProcPPC64Thread(ProcDebugger debugger, long id) {
>+    this.debugger = debugger;
>+    this.id = (int) id;
>+  }
>+
>+  public ThreadContext getContext() throws IllegalThreadStateException {
>+    ProcPPC64ThreadContext context = new ProcPPC64ThreadContext(debugger);
>+    long[] regs = debugger.getThreadIntegerRegisterSet(id);
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(regs.length <= PPC64ThreadContext.NPRGREG, "size of register set is greater than " + PPC64ThreadContext.NPRGREG);
>+    }
>+    for (int i = 0; i < regs.length; i++) {
>+      context.setRegister(i, regs[i]);
>+    }
>+    return context;
>+  }
>+
>+  public boolean canSetContext() throws DebuggerException {
>+    return false;
>+  }
>+
>+  public void setContext(ThreadContext context)
>+    throws IllegalThreadStateException, DebuggerException {
>+    throw new DebuggerException("Unimplemented");
>+  }
>+
>+  public String toString() {
>+    return "t@" + id;
>+  }
>+
>+  public boolean equals(Object obj) {
>+    if ((obj == null) || !(obj instanceof ProcPPC64Thread)) {
>+      return false;
>+    }
>+
>+    return (((ProcPPC64Thread) obj).id == id);
>+  }
>+
>+  public int hashCode() {
>+    return id;
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ppc64/ProcPPC64ThreadContext.java
>@@ -0,0 +1,46 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.proc.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.proc.*;
>+
>+public class ProcPPC64ThreadContext extends PPC64ThreadContext {
>+  private ProcDebugger debugger;
>+
>+  public ProcPPC64ThreadContext(ProcDebugger debugger) {
>+    super();
>+    this.debugger = debugger;
>+  }
>+
>+  public void setRegisterAsAddress(int index, Address value) {
>+    setRegister(index, debugger.getAddressValue(value));
>+  }
>+
>+  public Address getRegisterAsAddress(int index) {
>+    return debugger.newAddress(getRegister(index));
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ppc64/ProcPPC64ThreadFactory.java
>@@ -0,0 +1,44 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.proc.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.proc.*;
>+
>+public class ProcPPC64ThreadFactory implements ProcThreadFactory {
>+  private ProcDebugger debugger;
>+
>+  public ProcPPC64ThreadFactory(ProcDebugger debugger) {
>+    this.debugger = debugger;
>+  }
>+
>+  public ThreadProxy createThreadWrapper(Address threadIdentifierAddr) {
>+    return new ProcPPC64Thread(debugger, threadIdentifierAddr);
>+  }
>+
>+  public ThreadProxy createThreadWrapper(long id) {
>+    return new ProcPPC64Thread(debugger, id);
>+  }
>+}
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerClient.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerClient.java
>@@ -33,6 +33,7 @@
> import sun.jvm.hotspot.debugger.remote.sparc.*;
> import sun.jvm.hotspot.debugger.remote.x86.*;
> import sun.jvm.hotspot.debugger.remote.amd64.*;
>+import sun.jvm.hotspot.debugger.remote.ppc64.*;
> 
> /** An implementation of Debugger which wraps a
>     RemoteDebugger, providing remote debugging via RMI.
>@@ -70,6 +71,11 @@
>         cachePageSize = 4096;
>         cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);
>         unalignedAccessesOkay = true;
>+      } else if (cpu.equals("ppc64")) {
>+        threadFactory = new RemotePPC64ThreadFactory(this);
>+        cachePageSize = 4096;
>+        cacheNumPages = parseCacheNumPagesProperty(cacheSize / cachePageSize);
>+        unalignedAccessesOkay = true;
>       } else {
>         try {
>           Class tf = Class.forName("sun.jvm.hotspot.debugger.remote." +
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/ppc64/RemotePPC64Thread.java
>@@ -0,0 +1,53 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.remote.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.remote.*;
>+import sun.jvm.hotspot.utilities.*;
>+
>+public class RemotePPC64Thread extends RemoteThread  {
>+  public RemotePPC64Thread(RemoteDebuggerClient debugger, Address addr) {
>+    super(debugger, addr);
>+  }
>+
>+  public RemotePPC64Thread(RemoteDebuggerClient debugger, long id) {
>+    super(debugger, id);
>+  }
>+
>+  public ThreadContext getContext() throws IllegalThreadStateException {
>+    RemotePPC64ThreadContext context = new RemotePPC64ThreadContext(debugger);
>+    long[] regs = (addr != null)? debugger.getThreadIntegerRegisterSet(addr) :
>+      debugger.getThreadIntegerRegisterSet(id);
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(regs.length == PPC64ThreadContext.NPRGREG, "size of register set must match");
>+    }
>+    for (int i = 0; i < regs.length; i++) {
>+      context.setRegister(i, regs[i]);
>+    }
>+    return context;
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/ppc64/RemotePPC64ThreadContext.java
>@@ -0,0 +1,50 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.remote.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.debugger.remote.*;
>+
>+public class RemotePPC64ThreadContext extends PPC64ThreadContext {
>+  private RemoteDebuggerClient debugger;
>+
>+  public RemotePPC64ThreadContext(RemoteDebuggerClient debugger) {
>+    super();
>+    this.debugger = debugger;
>+  }
>+
>+  /** This can't be implemented in this class since we would have to
>+      tie the implementation to, for example, the debugging system */
>+  public void setRegisterAsAddress(int index, Address value) {
>+    setRegister(index, debugger.getAddressValue(value));
>+  }
>+
>+  /** This can't be implemented in this class since we would have to
>+      tie the implementation to, for example, the debugging system */
>+  public Address getRegisterAsAddress(int index) {
>+    return debugger.newAddress(getRegister(index));
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/ppc64/RemotePPC64ThreadFactory.java
>@@ -0,0 +1,44 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.debugger.remote.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.remote.*;
>+
>+public class RemotePPC64ThreadFactory implements RemoteThreadFactory {
>+  private RemoteDebuggerClient debugger;
>+
>+  public RemotePPC64ThreadFactory(RemoteDebuggerClient debugger) {
>+    this.debugger = debugger;
>+  }
>+
>+  public ThreadProxy createThreadWrapper(Address threadIdentifierAddr) {
>+    return new RemotePPC64Thread(debugger, threadIdentifierAddr);
>+  }
>+
>+  public ThreadProxy createThreadWrapper(long id) {
>+    return new RemotePPC64Thread(debugger, id);
>+  }
>+}
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/Threads.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/Threads.java
>@@ -34,9 +34,11 @@
> import sun.jvm.hotspot.runtime.win32_x86.Win32X86JavaThreadPDAccess;
> import sun.jvm.hotspot.runtime.linux_x86.LinuxX86JavaThreadPDAccess;
> import sun.jvm.hotspot.runtime.linux_amd64.LinuxAMD64JavaThreadPDAccess;
>+import sun.jvm.hotspot.runtime.linux_ppc64.LinuxPPC64JavaThreadPDAccess;
> import sun.jvm.hotspot.runtime.linux_sparc.LinuxSPARCJavaThreadPDAccess;
> import sun.jvm.hotspot.runtime.bsd_x86.BsdX86JavaThreadPDAccess;
> import sun.jvm.hotspot.runtime.bsd_amd64.BsdAMD64JavaThreadPDAccess;
>+import sun.jvm.hotspot.runtime.bsd_ppc64.BsdPPC64JavaThreadPDAccess;
> import sun.jvm.hotspot.utilities.*;
> 
> public class Threads {
>@@ -87,6 +89,8 @@
>                 access = new LinuxAMD64JavaThreadPDAccess();
>             } else if (cpu.equals("sparc")) {
>                 access = new LinuxSPARCJavaThreadPDAccess();
>+            } else if (cpu.equals("ppc64")) {
>+                access = new LinuxPPC64JavaThreadPDAccess();
>             } else {
>               try {
>                 access = (JavaThreadPDAccess)
>@@ -103,7 +107,9 @@
>                 access = new BsdX86JavaThreadPDAccess();
>             } else if (cpu.equals("amd64") || cpu.equals("x86_64")) {
>                 access = new BsdAMD64JavaThreadPDAccess();
>-            }
>+            } else if (cpu.equals("ppc64")) {
>+                access = new BsdPPC64JavaThreadPDAccess();
>+             }
>         } else if (os.equals("darwin")) {
>             if (cpu.equals("amd64") || cpu.equals("x86_64")) {
>                 access = new BsdAMD64JavaThreadPDAccess();
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/linux_ppc64/LinuxPPC64JavaThreadPDAccess.java
>@@ -0,0 +1,132 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.runtime.linux_ppc64;
>+
>+import java.io.*;
>+import java.util.*;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.runtime.*;
>+import sun.jvm.hotspot.runtime.ppc64.*;
>+import sun.jvm.hotspot.types.*;
>+import sun.jvm.hotspot.utilities.*;
>+
>+public class LinuxPPC64JavaThreadPDAccess implements JavaThreadPDAccess {
>+  private static AddressField  osThreadField;
>+
>+  // Field from OSThread
>+  private static CIntegerField osThreadThreadIDField;
>+
>+  // This is currently unneeded but is being kept in case we change
>+  // the currentFrameGuess algorithm
>+  private static final long GUESS_SCAN_RANGE = 128 * 1024;
>+
>+  static {
>+    VM.registerVMInitializedObserver(new Observer() {
>+        public void update(Observable o, Object data) {
>+          initialize(VM.getVM().getTypeDataBase());
>+        }
>+      });
>+  }
>+
>+  private static synchronized void initialize(TypeDataBase db) {
>+    Type type = db.lookupType("JavaThread");
>+    osThreadField           = type.getAddressField("_osthread");
>+
>+    Type osThreadType = db.lookupType("OSThread");
>+    osThreadThreadIDField   = osThreadType.getCIntegerField("_thread_id");
>+  }
>+
>+  public    Address getLastJavaFP(Address addr) {
>+    return null;
>+  }
>+
>+  public    Address getLastJavaPC(Address addr) {
>+    return null;
>+  }
>+
>+  public    Address getBaseOfStackPointer(Address addr) {
>+    return null;
>+  }
>+
>+  public    Frame getLastFramePD(JavaThread thread, Address addr) {
>+    Address fp = thread.getLastJavaFP();
>+    if (fp == null) {
>+      return null; // no information
>+    }
>+    return new PPC64Frame(thread.getLastJavaSP(), fp);
>+  }
>+
>+  public    RegisterMap newRegisterMap(JavaThread thread, boolean updateMap) {
>+    return new PPC64RegisterMap(thread, updateMap);
>+  }
>+
>+  public    Frame getCurrentFrameGuess(JavaThread thread, Address addr) {
>+    ThreadProxy t = getThreadProxy(addr);
>+    PPC64ThreadContext context = (PPC64ThreadContext) t.getContext();
>+    PPC64CurrentFrameGuess guesser = new PPC64CurrentFrameGuess(context, thread);
>+    if (!guesser.run(GUESS_SCAN_RANGE)) {
>+      return null;
>+    }
>+    if (guesser.getPC() == null) {
>+      return new PPC64Frame(guesser.getSP(), guesser.getFP());
>+    } else {
>+      return new PPC64Frame(guesser.getSP(), guesser.getFP(), guesser.getPC());
>+    }
>+  }
>+
>+  public    void printThreadIDOn(Address addr, PrintStream tty) {
>+    tty.print(getThreadProxy(addr));
>+  }
>+
>+  public    void printInfoOn(Address threadAddr, PrintStream tty) {
>+    tty.print("Thread id: ");
>+    printThreadIDOn(threadAddr, tty);
>+//    tty.println("\nPostJavaState: " + getPostJavaState(threadAddr));
>+  }
>+
>+  public    Address getLastSP(Address addr) {
>+    ThreadProxy t = getThreadProxy(addr);
>+    PPC64ThreadContext context = (PPC64ThreadContext) t.getContext();
>+    return context.getRegisterAsAddress(PPC64ThreadContext.SP);
>+  }
>+
>+  public Address getLastFP(Address addr) {
>+    return getLastSP(addr).getAddressAt(0);
>+  }
>+
>+  public    ThreadProxy getThreadProxy(Address addr) {
>+    // Addr is the address of the JavaThread.
>+    // Fetch the OSThread (for now and for simplicity, not making a
>+    // separate "OSThread" class in this package)
>+    Address osThreadAddr = osThreadField.getValue(addr);
>+    // Get the address of the _thread_id from the OSThread
>+    Address threadIdAddr = osThreadAddr.addOffsetTo(osThreadThreadIDField.getOffset());
>+
>+    JVMDebugger debugger = VM.getVM().getDebugger();
>+    return debugger.getThreadForIdentifierAddress(threadIdAddr);
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/bsd_ppc64/BsdPPC64JavaThreadPDAccess.java
>@@ -0,0 +1,132 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.runtime.bsd_ppc64;
>+
>+import java.io.*;
>+import java.util.*;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.runtime.*;
>+import sun.jvm.hotspot.runtime.ppc64.*;
>+import sun.jvm.hotspot.types.*;
>+import sun.jvm.hotspot.utilities.*;
>+
>+public class BsdPPC64JavaThreadPDAccess implements JavaThreadPDAccess {
>+  private static AddressField  osThreadField;
>+
>+  // Field from OSThread
>+  private static CIntegerField osThreadThreadIDField;
>+
>+  // This is currently unneeded but is being kept in case we change
>+  // the currentFrameGuess algorithm
>+  private static final long GUESS_SCAN_RANGE = 128 * 1024;
>+
>+  static {
>+    VM.registerVMInitializedObserver(new Observer() {
>+        public void update(Observable o, Object data) {
>+          initialize(VM.getVM().getTypeDataBase());
>+        }
>+      });
>+  }
>+
>+  private static synchronized void initialize(TypeDataBase db) {
>+    Type type = db.lookupType("JavaThread");
>+    osThreadField           = type.getAddressField("_osthread");
>+
>+    Type osThreadType = db.lookupType("OSThread");
>+    osThreadThreadIDField   = osThreadType.getCIntegerField("_thread_id");
>+  }
>+
>+  public    Address getLastJavaFP(Address addr) {
>+    return null;
>+  }
>+
>+  public    Address getLastJavaPC(Address addr) {
>+    return null;
>+  }
>+
>+  public    Address getBaseOfStackPointer(Address addr) {
>+    return null;
>+  }
>+
>+  public    Frame getLastFramePD(JavaThread thread, Address addr) {
>+    Address fp = thread.getLastJavaFP();
>+    if (fp == null) {
>+      return null; // no information
>+    }
>+    return new PPC64Frame(thread.getLastJavaSP(), fp);
>+  }
>+
>+  public    RegisterMap newRegisterMap(JavaThread thread, boolean updateMap) {
>+    return new PPC64RegisterMap(thread, updateMap);
>+  }
>+
>+  public    Frame getCurrentFrameGuess(JavaThread thread, Address addr) {
>+    ThreadProxy t = getThreadProxy(addr);
>+    PPC64ThreadContext context = (PPC64ThreadContext) t.getContext();
>+    PPC64CurrentFrameGuess guesser = new PPC64CurrentFrameGuess(context, thread);
>+    if (!guesser.run(GUESS_SCAN_RANGE)) {
>+      return null;
>+    }
>+    if (guesser.getPC() == null) {
>+      return new PPC64Frame(guesser.getSP(), guesser.getFP());
>+    } else {
>+      return new PPC64Frame(guesser.getSP(), guesser.getFP(), guesser.getPC());
>+    }
>+  }
>+
>+  public    void printThreadIDOn(Address addr, PrintStream tty) {
>+    tty.print(getThreadProxy(addr));
>+  }
>+
>+  public    void printInfoOn(Address threadAddr, PrintStream tty) {
>+    tty.print("Thread id: ");
>+    printThreadIDOn(threadAddr, tty);
>+//    tty.println("\nPostJavaState: " + getPostJavaState(threadAddr));
>+  }
>+
>+  public    Address getLastSP(Address addr) {
>+    ThreadProxy t = getThreadProxy(addr);
>+    PPC64ThreadContext context = (PPC64ThreadContext) t.getContext();
>+    return context.getRegisterAsAddress(PPC64ThreadContext.SP);
>+  }
>+
>+  public Address getLastFP(Address addr) {
>+    return getLastSP(addr).getAddressAt(0);
>+  }
>+
>+  public    ThreadProxy getThreadProxy(Address addr) {
>+    // Addr is the address of the JavaThread.
>+    // Fetch the OSThread (for now and for simplicity, not making a
>+    // separate "OSThread" class in this package)
>+    Address osThreadAddr = osThreadField.getValue(addr);
>+    // Get the address of the _thread_id from the OSThread
>+    Address threadIdAddr = osThreadAddr.addOffsetTo(osThreadThreadIDField.getOffset());
>+
>+    JVMDebugger debugger = VM.getVM().getDebugger();
>+    return debugger.getThreadForIdentifierAddress(threadIdAddr);
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/ppc64/PPC64CurrentFrameGuess.java
>@@ -0,0 +1,176 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.runtime.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.debugger.ppc64.*;
>+import sun.jvm.hotspot.code.*;
>+import sun.jvm.hotspot.interpreter.*;
>+import sun.jvm.hotspot.runtime.*;
>+import sun.jvm.hotspot.runtime.ppc64.*;
>+
>+/** <P> Should be able to be used on all ppc64 platforms we support
>+    (Linux/ppc64) to implement JavaThread's "currentFrameGuess()"
>+    functionality. Input is a PPC64ThreadContext; output is SP, FP,
>+    and PC for an PPC64Frame. Instantiation of the PPC64Frame is left
>+    to the caller, since we may need to subclass PPC64Frame to support
>+    signal handler frames on Unix platforms. </P>
>+ */
>+
>+public class PPC64CurrentFrameGuess {
>+  private PPC64ThreadContext context;
>+  private JavaThread       thread;
>+  private Address          spFound;
>+  private Address          fpFound;
>+  private Address          pcFound;
>+
>+  private static final boolean DEBUG = System.getProperty("sun.jvm.hotspot.runtime.ppc64.PPC64Frame.DEBUG")
>+                                       != null;
>+
>+  public PPC64CurrentFrameGuess(PPC64ThreadContext context,
>+                              JavaThread thread) {
>+    this.context = context;
>+    this.thread  = thread;
>+  }
>+
>+  /** Returns false if not able to find a frame within a reasonable range. */
>+  public boolean run(long regionInBytesToSearch) {
>+    Address sp  = context.getRegisterAsAddress(PPC64ThreadContext.SP);
>+    Address pc  = context.getRegisterAsAddress(PPC64ThreadContext.PC);
>+    if (sp == null) {
>+      // Bail out if no last java frame either
>+      if (thread.getLastJavaSP() != null) {
>+        Address javaSP = thread.getLastJavaSP();
>+        Address javaFP = javaSP.getAddressAt(0);
>+        setValues(javaSP, javaFP, null);
>+        return true;
>+      }
>+      return false;
>+    }
>+    /* There is no frame pointer per se for the ppc64 architecture.  To mirror
>+     * the behavior of the VM frame manager, we set fp to be the caller's (i.e., "sender's")
>+     * stack pointer, which is the back chain value contained in our sp.
>+     */
>+    Address fp = sp.getAddressAt(0);
>+    setValues(null, null, null); // Assume we're not going to find anything
>+
>+    VM vm = VM.getVM();
>+    if (vm.isJavaPCDbg(pc)) {
>+      if (vm.isClientCompiler()) {
>+        // Topmost frame is a Java frame.
>+        if (DEBUG) {
>+          System.out.println("CurrentFrameGuess: choosing compiler frame: sp = " +
>+                             sp + ", fp = " + fp + ", pc = " + pc);
>+        }
>+        setValues(sp, fp, pc);
>+        return true;
>+      } else {
>+        if (vm.getInterpreter().contains(pc)) {
>+          if (DEBUG) {
>+            System.out.println("CurrentFrameGuess: choosing interpreter frame: sp = " +
>+                               sp + ", fp = " + fp + ", pc = " + pc);
>+          }
>+          setValues(sp, fp, pc);
>+          return true;
>+        }
>+
>+        // This algorithm takes the current PC as a given and tries to
>+        // find the correct corresponding SP by walking up the stack
>+        // and repeatedly performing stackwalks (very inefficient).
>+        for (long offset = 0;
>+             offset < regionInBytesToSearch;
>+             offset += vm.getAddressSize()) {
>+          try {
>+            Address curSP = sp.addOffsetTo(offset);
>+            fp = curSP.getAddressAt(0);
>+            Frame frame = new PPC64Frame(curSP, fp, pc);
>+            RegisterMap map = thread.newRegisterMap(false);
>+            while (frame != null) {
>+              if (frame.isEntryFrame() && frame.entryFrameIsFirst()) {
>+                // We were able to traverse all the way to the
>+                // bottommost Java frame.
>+                // This sp looks good. Keep it.
>+                if (DEBUG) {
>+                  System.out.println("CurrentFrameGuess: Choosing sp = " + curSP + ", pc = " + pc);
>+                }
>+                setValues(curSP, fp, pc);
>+                return true;
>+              }
>+              frame = frame.sender(map);
>+            }
>+          } catch (Exception e) {
>+            if (DEBUG) {
>+              System.out.println("CurrentFrameGuess: Exception " + e + " at offset " + offset);
>+            }
>+            // Bad SP. Try another.
>+          }
>+        }
>+
>+        // Were not able to find a plausible SP to go with this PC.
>+        // Bail out.
>+        return false;
>+
>+      }
>+    } else {
>+      // If the current program counter was not known to us as a Java
>+      // PC, we currently assume that we are in the run-time system
>+      // and attempt to look to thread-local storage for saved java SP.
>+      // Note that if this is null (because we were, in fact,
>+      // in Java code, i.e., vtable stubs or similar, and the SA
>+      // didn't have enough insight into the target VM to understand
>+      // that) then we are going to lose the entire stack trace for
>+      // the thread, which is sub-optimal. FIXME.
>+
>+      if (thread.getLastJavaSP() == null) {
>+        if (DEBUG)
>+          System.out.println("CurrentFrameGuess: last java sp is null");
>+        return false; // No known Java frames on stack
>+      }
>+
>+      Address javaSP = thread.getLastJavaSP();
>+      Address javaFP = javaSP.getAddressAt(0);
>+      Address javaPC = thread.getLastJavaPC();
>+      if (DEBUG) {
>+        System.out.println("CurrentFrameGuess: choosing last Java frame: sp = " +
>+                           javaSP + ", fp = " + javaFP + ", pc = " + javaPC);
>+      }
>+      setValues(javaSP, javaFP, javaPC);
>+      return true;
>+    }
>+  }
>+
>+  public Address getSP() { return spFound; }
>+  public Address getFP() { return fpFound; }
>+  /** May be null if getting values from thread-local storage; take
>+      care to call the correct PPC64Frame constructor to recover this if
>+      necessary */
>+  public Address getPC() { return pcFound; }
>+
>+  private void setValues(Address sp, Address fp, Address pc) {
>+    spFound = sp;
>+    fpFound = fp;
>+    pcFound = pc;
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/ppc64/PPC64Frame.java
>@@ -0,0 +1,508 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.runtime.ppc64;
>+
>+import java.util.*;
>+import sun.jvm.hotspot.code.*;
>+import sun.jvm.hotspot.compiler.*;
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.oops.*;
>+import sun.jvm.hotspot.runtime.*;
>+import sun.jvm.hotspot.types.*;
>+import sun.jvm.hotspot.utilities.*;
>+
>+/** Specialization of and implementation of abstract methods of the
>+    Frame class for the ppc64 family of CPUs. */
>+
>+public class PPC64Frame extends Frame {
>+  private static final boolean DEBUG;
>+  static {
>+    DEBUG = System.getProperty("sun.jvm.hotspot.runtime.ppc64.PPC64Frame.DEBUG") != null;
>+  }
>+
>+  // All frames
>+  private static final int SENDER_SP_OFFSET           =  0;
>+
>+  // Interpreter frames
>+  private static final int INTERPRETER_FRAME_MIRROR_OFFSET    =  -3; // for native calls only
>+  private static final int INTERPRETER_FRAME_SENDER_SP_OFFSET = -4;
>+  private static final int INTERPRETER_FRAME_LAST_SP_OFFSET   = INTERPRETER_FRAME_SENDER_SP_OFFSET - 1;
>+  private static final int INTERPRETER_FRAME_MDX_OFFSET = INTERPRETER_FRAME_LAST_SP_OFFSET -1;
>+  private static final  int INTERPRETER_FRAME_ESP_OFFSET = INTERPRETER_FRAME_MDX_OFFSET - 1;
>+  private static final int INTERPRETER_FRAME_BCX_OFFSET = INTERPRETER_FRAME_ESP_OFFSET - 1;
>+  private static final int INTERPRETER_FRAME_CACHE_OFFSET =INTERPRETER_FRAME_BCX_OFFSET - 1;
>+  private static final int INTERPRETER_FRAME_MONITORS_OFFSET = INTERPRETER_FRAME_CACHE_OFFSET - 1;
>+  private static final int INTERPRETER_FRAME_LOCALS_OFFSET = INTERPRETER_FRAME_MONITORS_OFFSET - 1;
>+  private static final int INTERPRETER_FRAME_METHOD_OFFSET = INTERPRETER_FRAME_LOCALS_OFFSET - 1;
>+  private static final int INTERPRETER_FRAME_INITIAL_SP_OFFSET = INTERPRETER_FRAME_BCX_OFFSET - 1; // FIXME: probably wrong, but unused anyway
>+  private static final int INTERPRETER_FRAME_MONITOR_BLOCK_TOP_OFFSET    = INTERPRETER_FRAME_INITIAL_SP_OFFSET;
>+  private static final int INTERPRETER_FRAME_MONITOR_BLOCK_BOTTOM_OFFSET = INTERPRETER_FRAME_INITIAL_SP_OFFSET;
>+
>+  // Entry frames
>+  private static       int ENTRY_FRAME_CALL_WRAPPER_OFFSET;
>+
>+  // Native frames
>+  private static       int NATIVE_FRAME_INITIAL_PARAM_OFFSET;
>+
>+
>+  static {
>+    VM.registerVMInitializedObserver(new Observer() {
>+      public void update(Observable o, Object data) {
>+        initialize(VM.getVM().getTypeDataBase());
>+      }
>+    });
>+  }
>+
>+  private static synchronized void initialize(TypeDataBase db) {
>+    int abi_minframe_size = db.lookupIntConstant("frame::abi_minframe_size").intValue();
>+    int entry_frame_locals_size = db.lookupIntConstant("frame::entry_frame_locals_size").intValue();
>+    int wordLength = (int)VM.getVM().getAddressSize();
>+    NATIVE_FRAME_INITIAL_PARAM_OFFSET = -abi_minframe_size/wordLength;
>+    ENTRY_FRAME_CALL_WRAPPER_OFFSET = -entry_frame_locals_size/wordLength;
>+  }
>+
>+
>+  // an additional field beyond sp and pc:
>+  Address raw_fp; // frame pointer
>+  private Address raw_unextendedSP;
>+
>+  private PPC64Frame() {
>+  }
>+
>+  private void adjustForDeopt() {
>+    if ( pc != null) {
>+      // Look for a deopt pc and if it is deopted convert to original pc
>+      CodeBlob cb = VM.getVM().getCodeCache().findBlob(pc);
>+      if (cb != null && cb.isJavaMethod()) {
>+        NMethod nm = (NMethod) cb;
>+        if (pc.equals(nm.deoptHandlerBegin())) {
>+          if (Assert.ASSERTS_ENABLED) {
>+            Assert.that(this.getUnextendedSP() != null, "null SP in Java frame");
>+          }
>+          // adjust pc if frame is deoptimized.
>+          pc = this.getUnextendedSP().getAddressAt(nm.origPCOffset());
>+          deoptimized = true;
>+        }
>+      }
>+    }
>+  }
>+
>+  public PPC64Frame(Address raw_sp, Address raw_fp, Address pc) {
>+    this.raw_sp = raw_sp;
>+    this.raw_unextendedSP = raw_sp;
>+    if (raw_fp == null)
>+      this.raw_fp = raw_sp.getAddressAt(0);
>+    else
>+      this.raw_fp = raw_fp;
>+    if (pc == null)
>+      this.pc = raw_sp.getAddressAt(2 * VM.getVM().getAddressSize());
>+    else
>+      this.pc = pc;
>+    adjustUnextendedSP();
>+
>+    // Frame must be fully constructed before this call
>+    adjustForDeopt();
>+
>+    if (DEBUG) {
>+      System.out.println("PPC64Frame(sp, fp, pc): " + this);
>+      dumpStack();
>+    }
>+  }
>+
>+  public PPC64Frame(Address raw_sp, Address raw_fp) {
>+    this.raw_sp = raw_sp;
>+    this.raw_unextendedSP = raw_sp;
>+    if (raw_fp == null)
>+      this.raw_fp = raw_sp.getAddressAt(0);
>+    else
>+      this.raw_fp = raw_fp;
>+    this.pc = raw_sp.getAddressAt(2 * VM.getVM().getAddressSize());
>+    adjustUnextendedSP();
>+
>+    // Frame must be fully constructed before this call
>+    adjustForDeopt();
>+
>+    if (DEBUG) {
>+      System.out.println("PPC64Frame(sp, fp): " + this);
>+      dumpStack();
>+    }
>+  }
>+
>+  public PPC64Frame(Address raw_sp, Address raw_unextendedSp, Address raw_fp, Address pc) {
>+    this.raw_sp = raw_sp;
>+    this.raw_unextendedSP = raw_unextendedSp;
>+    if (raw_fp == null)
>+      this.raw_fp = raw_sp.getAddressAt(0);
>+    else
>+      this.raw_fp = raw_fp;
>+    if (pc == null)
>+      this.pc = raw_sp.getAddressAt(2 * VM.getVM().getAddressSize());
>+    else
>+      this.pc = pc;
>+    adjustUnextendedSP();
>+
>+    // Frame must be fully constructed before this call
>+    adjustForDeopt();
>+
>+    if (DEBUG) {
>+      System.out.println("PPC64Frame(sp, unextendedSP, fp, pc): " + this);
>+      dumpStack();
>+    }
>+
>+  }
>+
>+  public Object clone() {
>+    PPC64Frame frame = new PPC64Frame();
>+    frame.raw_sp = raw_sp;
>+    frame.raw_unextendedSP = raw_unextendedSP;
>+    frame.raw_fp = raw_fp;
>+    frame.pc = pc;
>+    frame.deoptimized = deoptimized;
>+    return frame;
>+  }
>+
>+  public boolean equals(Object arg) {
>+    if (arg == null) {
>+      return false;
>+    }
>+
>+    if (!(arg instanceof PPC64Frame)) {
>+      return false;
>+    }
>+
>+    PPC64Frame other = (PPC64Frame) arg;
>+
>+    return (AddressOps.equal(getSP(), other.getSP()) &&
>+        AddressOps.equal(getUnextendedSP(), other.getUnextendedSP()) &&
>+        AddressOps.equal(getFP(), other.getFP()) &&
>+        AddressOps.equal(getPC(), other.getPC()));
>+  }
>+
>+  public int hashCode() {
>+    if (raw_sp == null) {
>+      return 0;
>+    }
>+
>+    return raw_sp.hashCode();
>+  }
>+
>+  public String toString() {
>+    return "sp: " + (getSP() == null? "null" : getSP().toString()) +
>+        ", unextendedSP: " + (getUnextendedSP() == null? "null" : getUnextendedSP().toString()) +
>+        ", fp: " + (getFP() == null? "null" : getFP().toString()) +
>+        ", pc: " + (pc == null? "null" : pc.toString());
>+  }
>+
>+  // accessors for the instance variables
>+  public Address getFP() { return raw_fp; }
>+  public Address getSP() { return raw_sp; }
>+  public Address getID() { return raw_sp; }
>+
>+  // FIXME: not implemented yet (should be done for Solaris/PPC64)
>+  public boolean isSignalHandlerFrameDbg() { return false; }
>+  public int     getSignalNumberDbg()      { return 0;     }
>+  public String  getSignalNameDbg()        { return null;  }
>+
>+  public boolean isInterpretedFrameValid() {
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(isInterpretedFrame(), "Not an interpreted frame");
>+    }
>+
>+    // These are reasonable sanity checks
>+    if (getFP() == null || getFP().andWithMask(0x3) != null) {
>+      return false;
>+    }
>+
>+    if (getSP() == null || getSP().andWithMask(0x3) != null) {
>+      return false;
>+    }
>+
>+    // These are hacks to keep us out of trouble.
>+    // The problem with these is that they mask other problems
>+    if (getFP().lessThanOrEqual(getSP())) {
>+      // this attempts to deal with unsigned comparison above
>+      return false;
>+    }
>+
>+    if (getFP().minus(getSP()) > 4096 * VM.getVM().getAddressSize()) {
>+      // stack frames shouldn't be large.
>+      return false;
>+    }
>+
>+    return true;
>+  }
>+
>+  // FIXME: not applicable in current system
>+  //  void    patch_pc(Thread* thread, address pc);
>+
>+  public Frame sender(RegisterMap regMap, CodeBlob cb) {
>+    PPC64RegisterMap map = (PPC64RegisterMap) regMap;
>+
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(map != null, "map must be set");
>+    }
>+
>+    // Default is we done have to follow them. The sender_for_xxx will
>+    // update it accordingly
>+    map.setIncludeArgumentOops(false);
>+
>+    if (isEntryFrame())       return senderForEntryFrame(map);
>+    if (isInterpretedFrame()) return senderForInterpreterFrame(map);
>+
>+    if(cb == null) {
>+      cb = VM.getVM().getCodeCache().findBlob(getPC());
>+    } else {
>+      if (Assert.ASSERTS_ENABLED) {
>+        Assert.that(cb.equals(VM.getVM().getCodeCache().findBlob(getPC())), "Must be the same");
>+      }
>+    }
>+
>+    if (cb != null) {
>+      return senderForCompiledFrame(map, cb);
>+    }
>+
>+    // Must be native-compiled frame, i.e. the marshaling code for native
>+    // methods that exists in the core system.
>+    return new PPC64Frame(getSenderSP(), getLink(), getSenderPC());
>+  }
>+
>+  private Frame senderForEntryFrame(PPC64RegisterMap map) {
>+    if (DEBUG) {
>+      System.out.println("senderForEntryFrame");
>+    }
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(map != null, "map must be set");
>+    }
>+    // Java frame called from C; skip all C frames and return top C
>+    // frame of that chunk as the sender
>+    PPC64JavaCallWrapper jcw = (PPC64JavaCallWrapper) getEntryFrameCallWrapper();
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(!entryFrameIsFirst(), "next Java fp must be non zero");
>+      Assert.that(jcw.getLastJavaSP().greaterThan(getSP()), "must be above this frame on stack");
>+    }
>+    PPC64Frame fr;
>+    if (jcw.getLastJavaPC() != null) {
>+      fr = new PPC64Frame(jcw.getLastJavaSP(), jcw.getLastJavaFP(), jcw.getLastJavaPC());
>+    } else {
>+      fr = new PPC64Frame(jcw.getLastJavaSP(), jcw.getLastJavaFP());
>+    }
>+    map.clear();
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(map.getIncludeArgumentOops(), "should be set by clear");
>+    }
>+    return fr;
>+  }
>+
>+  //------------------------------------------------------------------------------
>+  // frame::adjust_unextended_sp
>+  private void adjustUnextendedSP() {
>+    raw_unextendedSP = getFP();
>+  }
>+  private Frame senderForInterpreterFrame(PPC64RegisterMap map) {
>+    if (DEBUG) {
>+      System.out.println("senderForInterpreterFrame");
>+    }
>+    Address unextendedSP = addressOfStackSlot(INTERPRETER_FRAME_SENDER_SP_OFFSET).getAddressAt(0);
>+    Address sp = getSenderSP();
>+
>+    return new PPC64Frame(sp, unextendedSP, getLink(), getSenderPC());
>+  }
>+
>+
>+  private Frame senderForCompiledFrame(PPC64RegisterMap map, CodeBlob cb) {
>+    if (DEBUG) {
>+      System.out.println("senderForCompiledFrame");
>+    }
>+
>+    //
>+    // NOTE: some of this code is (unfortunately) duplicated in PPC64CurrentFrameGuess
>+    //
>+
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(map != null, "map must be set");
>+    }
>+
>+    // frame owned by optimizing compiler
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(cb.getFrameSize() >= 0, "must have non-zero frame size");
>+    }
>+    Address senderSP = getSenderSP();
>+
>+    Address senderPC = getSenderPC();
>+
>+    if (map.getUpdateMap()) {
>+      // Tell GC to use argument oopmaps for some runtime stubs that need it.
>+      // For C1, the runtime stub might not have oop maps, so set this flag
>+      // outside of update_register_map.
>+      map.setIncludeArgumentOops(cb.callerMustGCArguments());
>+
>+      if (cb.getOopMaps() != null) {
>+        OopMapSet.updateRegisterMap(this, cb, map, true);
>+      }
>+    }
>+
>+    return new PPC64Frame(senderSP, getLink(), senderPC);
>+  }
>+
>+  protected boolean hasSenderPD() {
>+    // FIXME
>+    return true;
>+  }
>+
>+  public long frameSize() {
>+    return (getSenderSP().minus(getSP()) / VM.getVM().getAddressSize());
>+  }
>+
>+  public Address getLink() {
>+    return getSenderSP().getAddressAt(0);
>+  }
>+
>+  public Address getUnextendedSP() { return raw_unextendedSP; }
>+
>+  // Return address:
>+  public Address getSenderPC()     { return getSenderSP().getAddressAt(2 * VM.getVM().getAddressSize()); }
>+
>+  // return address of param, zero origin index.
>+  // MPJ note:   Appears to be unused.
>+  public Address getNativeParamAddr(int idx) {
>+    return null;
>+    // return addressOfStackSlot(NATIVE_FRAME_INITIAL_PARAM_OFFSET + idx);
>+  }
>+
>+  public Address getSenderSP()     { return getFP(); }
>+  public Address addressOfInterpreterFrameLocals() {
>+    return addressOfStackSlot(INTERPRETER_FRAME_LOCALS_OFFSET);
>+  }
>+
>+  private Address addressOfInterpreterFrameBCX() {
>+    return addressOfStackSlot(INTERPRETER_FRAME_BCX_OFFSET);
>+  }
>+
>+  public int getInterpreterFrameBCI() {
>+    // FIXME: this is not atomic with respect to GC and is unsuitable
>+    // for use in a non-debugging, or reflective, system. Need to
>+    // figure out how to express this.
>+    Address bcp = addressOfInterpreterFrameBCX().getAddressAt(0);
>+    Address methodHandle = addressOfInterpreterFrameMethod().getAddressAt(0);
>+    Method method = (Method)Metadata.instantiateWrapperFor(methodHandle);
>+    return bcpToBci(bcp, method);
>+  }
>+
>+  public Address addressOfInterpreterFrameMDX() {
>+    return addressOfStackSlot(INTERPRETER_FRAME_MDX_OFFSET);
>+  }
>+
>+  // FIXME
>+  //inline int frame::interpreter_frame_monitor_size() {
>+  //  return BasicObjectLock::size();
>+  //}
>+
>+  // expression stack
>+  // (the max_stack arguments are used by the GC; see class FrameClosure)
>+
>+  public Address addressOfInterpreterFrameExpressionStack() {
>+    Address monitorEnd = interpreterFrameMonitorEnd().address();
>+    return monitorEnd.addOffsetTo(-1 * VM.getVM().getAddressSize());
>+  }
>+
>+  public int getInterpreterFrameExpressionStackDirection() { return -1; }
>+
>+  // top of expression stack
>+  public Address addressOfInterpreterFrameTOS() {
>+    return getSP();
>+  }
>+
>+  /** Expression stack from top down */
>+  public Address addressOfInterpreterFrameTOSAt(int slot) {
>+    return addressOfInterpreterFrameTOS().addOffsetTo(slot * VM.getVM().getAddressSize());
>+  }
>+
>+  public Address getInterpreterFrameSenderSP() {
>+    if (Assert.ASSERTS_ENABLED) {
>+      Assert.that(isInterpretedFrame(), "interpreted frame expected");
>+    }
>+    return addressOfStackSlot(INTERPRETER_FRAME_SENDER_SP_OFFSET).getAddressAt(0);
>+  }
>+
>+  // Monitors
>+  public BasicObjectLock interpreterFrameMonitorBegin() {
>+    return new BasicObjectLock(addressOfStackSlot(INTERPRETER_FRAME_MONITOR_BLOCK_BOTTOM_OFFSET));
>+  }
>+
>+  public BasicObjectLock interpreterFrameMonitorEnd() {
>+    Address result = addressOfStackSlot(INTERPRETER_FRAME_MONITOR_BLOCK_TOP_OFFSET).getAddressAt(0);
>+    if (Assert.ASSERTS_ENABLED) {
>+      // make sure the pointer points inside the frame
>+      Assert.that(AddressOps.gt(getFP(), result), "result must <  than frame pointer");
>+      Assert.that(AddressOps.lte(getSP(), result), "result must >= than stack pointer");
>+    }
>+    return new BasicObjectLock(result);
>+  }
>+
>+  public int interpreterFrameMonitorSize() {
>+    return BasicObjectLock.size();
>+  }
>+
>+  // Method
>+  public Address addressOfInterpreterFrameMethod() {
>+    return addressOfStackSlot(INTERPRETER_FRAME_METHOD_OFFSET);
>+  }
>+
>+  // Constant pool cache
>+  public Address addressOfInterpreterFrameCPCache() {
>+    return addressOfStackSlot(INTERPRETER_FRAME_CACHE_OFFSET);
>+  }
>+
>+  // Entry frames
>+  public JavaCallWrapper getEntryFrameCallWrapper() {
>+    return new PPC64JavaCallWrapper(addressOfStackSlot(ENTRY_FRAME_CALL_WRAPPER_OFFSET).getAddressAt(0));
>+  }
>+
>+  protected Address addressOfSavedOopResult() {
>+    // offset is 2 for compiler2 and 3 for compiler1
>+    return getSP().addOffsetTo((VM.getVM().isClientCompiler() ? 2 : 3) *
>+        VM.getVM().getAddressSize());
>+  }
>+
>+  protected Address addressOfSavedReceiver() {
>+    return getSP().addOffsetTo(-4 * VM.getVM().getAddressSize());
>+  }
>+
>+  private void dumpStack() {
>+    if (getFP() != null) {
>+      for (Address addr = getSP().addOffsetTo(-5 * VM.getVM().getAddressSize());
>+          AddressOps.lte(addr, getFP().addOffsetTo(5 * VM.getVM().getAddressSize()));
>+          addr = addr.addOffsetTo(VM.getVM().getAddressSize())) {
>+        System.out.println(addr + ": " + addr.getAddressAt(0));
>+      }
>+    } else {
>+      for (Address addr = getSP().addOffsetTo(-5 * VM.getVM().getAddressSize());
>+          AddressOps.lte(addr, getSP().addOffsetTo(20 * VM.getVM().getAddressSize()));
>+          addr = addr.addOffsetTo(VM.getVM().getAddressSize())) {
>+        System.out.println(addr + ": " + addr.getAddressAt(0));
>+      }
>+    }
>+  }
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/ppc64/PPC64JavaCallWrapper.java
>@@ -0,0 +1,43 @@
>+/*
>+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.runtime.ppc64;
>+
>+import java.util.*;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.types.*;
>+import sun.jvm.hotspot.runtime.*;
>+
>+public class PPC64JavaCallWrapper extends JavaCallWrapper {
>+
>+  public PPC64JavaCallWrapper(Address addr) {
>+    super(addr);
>+  }
>+
>+  public Address getLastJavaFP() {
>+    return null;
>+  }
>+
>+}
>--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/ppc64/PPC64RegisterMap.java
>@@ -0,0 +1,51 @@
>+/*
>+ * Copyright (c) 20014, Oracle and/or its affiliates. All rights reserved.
>+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
>+ *
>+ * This code is free software; you can redistribute it and/or modify it
>+ * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
>+ * or visit www.oracle.com if you need additional information or have any
>+ * questions.
>+ *
>+ */
>+
>+package sun.jvm.hotspot.runtime.ppc64;
>+
>+import sun.jvm.hotspot.debugger.*;
>+import sun.jvm.hotspot.runtime.*;
>+
>+public class PPC64RegisterMap extends RegisterMap {
>+
>+  /** This is the only public constructor */
>+  public PPC64RegisterMap(JavaThread thread, boolean updateMap) {
>+    super(thread, updateMap);
>+  }
>+
>+  protected PPC64RegisterMap(RegisterMap map) {
>+    super(map);
>+  }
>+
>+  public Object clone() {
>+    PPC64RegisterMap retval = new PPC64RegisterMap(this);
>+    return retval;
>+  }
>+
>+  // no PD state to clear or copy:
>+  protected void clearPD() {}
>+  protected void initializePD() {}
>+  protected void initializeFromPD(RegisterMap map) {}
>+  protected Address getLocationPD(VMReg reg) { return null; }
>+}
>--- ./hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/PlatformInfo.java
>+++ ./hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/PlatformInfo.java
>@@ -61,7 +61,7 @@
>       return "x86";
>     } else if (cpu.equals("sparc") || cpu.equals("sparcv9")) {
>       return "sparc";
>-    } else if (cpu.equals("ia64") || cpu.equals("amd64") || cpu.equals("x86_64")) {
>+    } else if (cpu.equals("ia64") || cpu.equals("amd64") || cpu.equals("x86_64") || cpu.equals("ppc64")) {
>       return cpu;
>     } else {
>       try {
>--- ./hotspot/make/bsd/makefiles/sa.make
>+++ ./hotspot/make/bsd/makefiles/sa.make
>@@ -1,5 +1,5 @@
> #
>-# Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
>+# Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
> # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
> #
> # This code is free software; you can redistribute it and/or modify it
>@@ -19,7 +19,7 @@
> # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
> # or visit www.oracle.com if you need additional information or have any
> # questions.
>-#  
>+#
> #
> 
> # This makefile (sa.make) is included from the sa.make in the
>@@ -30,34 +30,21 @@
> 
> include $(GAMMADIR)/make/bsd/makefiles/rules.make
> 
>+include $(GAMMADIR)/make/defs.make
>+include $(GAMMADIR)/make/altsrc.make
>+
> AGENT_DIR = $(GAMMADIR)/agent
> 
> include $(GAMMADIR)/make/sa.files
> 
> -include $(HS_ALT_MAKE)/bsd/makefiles/sa.make
> 
>+
> TOPDIR    = $(shell echo `pwd`)
> GENERATED = $(TOPDIR)/../generated
> 
>-# SA-JDI depends on the standard JDI classes.
>-# Default SA_CLASSPATH location:
>-DEF_SA_CLASSPATH=$(BOOT_JAVA_HOME)/lib/tools.jar
>-ifeq ($(ALT_SA_CLASSPATH),)
>-  # no alternate specified; see if default exists
>-  SA_CLASSPATH=$(shell test -f $(DEF_SA_CLASSPATH) && echo $(DEF_SA_CLASSPATH))
>-  ifeq ($(SA_CLASSPATH),)
>-    # the default doesn't exist
>-    ifeq ($(OS_VENDOR), Darwin)
>-      # A JDK from Apple doesn't have tools.jar; the JDI classes are
>-      # are in the regular classes.jar file.
>-      APPLE_JAR=$(BOOT_JAVA_HOME)/bundle/Classes/classes.jar
>-      SA_CLASSPATH=$(shell test -f $(APPLE_JAR) && echo $(APPLE_JAR))
>-    endif
>-  endif
>-else
>-  _JUNK_ := $(shell echo >&2 "INFO: ALT_SA_CLASSPATH=$(ALT_SA_CLASSPATH)")
>-  SA_CLASSPATH=$(shell test -f $(ALT_SA_CLASSPATH) && echo $(ALT_SA_CLASSPATH))
>-endif
>+# tools.jar is needed by the JDI - SA binding
>+SA_CLASSPATH = $(BOOT_JAVA_HOME)/lib/tools.jar
> 
> # TODO: if it's a modules image, check if SA module is installed.
> MODULELIB_PATH= $(BOOT_JAVA_HOME)/lib/modules
>@@ -71,24 +58,22 @@
> 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, PowerPC, ARM or zero.
>+# also, we don't build SA on Itanium or zero.
> 
>-all: 
>+all:
> 	if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" \
>-             -a "$(SRCARCH)" != "arm" \
>-             -a "$(SRCARCH)" != "ppc" \
>              -a "$(SRCARCH)" != "zero" ] ; then \
> 	   $(MAKE) -f sa.make $(GENERATED)/sa-jdi.jar; \
> 	fi
> 
>-$(GENERATED)/sa-jdi.jar: $(AGENT_FILES)
>-	$(QUIETLY) echo "Making $@"
>+$(GENERATED)/sa-jdi.jar:: $(AGENT_FILES)
>+	$(QUIETLY) echo $(LOG_INFO) "Making $@"
> 	$(QUIETLY) if [ "$(BOOT_JAVA_HOME)" = "" ]; then \
> 	  echo "ALT_BOOTDIR, BOOTDIR or JAVA_HOME needs to be defined to build SA"; \
> 	  exit 1; \
> 	fi
>-	$(QUIETLY) if [ ! -f "$(SA_CLASSPATH)" -a ! -d $(MODULELIB_PATH) ] ; then \
>-	  echo "Cannot find JDI classes. Use 1.6.0 or later version of JDK."; \
>+	$(QUIETLY) if [ ! -f $(SA_CLASSPATH) -a ! -d $(MODULELIB_PATH) ] ; then \
>+	  echo "Missing $(SA_CLASSPATH) file. Use 1.6.0 or later version of JDK";\
> 	  echo ""; \
> 	  exit 1; \
> 	fi
>@@ -114,19 +99,22 @@
> 	$(QUIETLY) $(REMOTE) $(COMPILE.RMIC)  -classpath $(SA_CLASSDIR) -d $(SA_CLASSDIR) sun.jvm.hotspot.debugger.remote.RemoteDebuggerServer
> 	$(QUIETLY) echo "$(SA_BUILD_VERSION_PROP)" > $(SA_PROPERTIES)
> 	$(QUIETLY) rm -f $(SA_CLASSDIR)/sun/jvm/hotspot/utilities/soql/sa.js
>-	$(QUIETLY) cp $(AGENT_SRC_DIR)/sun/jvm/hotspot/utilities/soql/sa.js $(SA_CLASSDIR)/sun/jvm/hotspot/utilities/soql
>+	$(QUIETLY) $(CP) $(AGENT_SRC_DIR)/sun/jvm/hotspot/utilities/soql/sa.js $(SA_CLASSDIR)/sun/jvm/hotspot/utilities/soql
> 	$(QUIETLY) mkdir -p $(SA_CLASSDIR)/sun/jvm/hotspot/ui/resources
> 	$(QUIETLY) rm -f $(SA_CLASSDIR)/sun/jvm/hotspot/ui/resources/*
>-	$(QUIETLY) cp $(AGENT_SRC_DIR)/sun/jvm/hotspot/ui/resources/*.png $(SA_CLASSDIR)/sun/jvm/hotspot/ui/resources/
>-	$(QUIETLY) cp -r $(AGENT_SRC_DIR)/images/* $(SA_CLASSDIR)/
>+	$(QUIETLY) $(CP) $(AGENT_SRC_DIR)/sun/jvm/hotspot/ui/resources/*.png $(SA_CLASSDIR)/sun/jvm/hotspot/ui/resources/
>+	$(QUIETLY) $(CP) -r $(AGENT_SRC_DIR)/images/* $(SA_CLASSDIR)/
> 	$(QUIETLY) $(REMOTE) $(RUN.JAR) cf $@ -C $(SA_CLASSDIR)/ .
> 	$(QUIETLY) $(REMOTE) $(RUN.JAR) uf $@ -C $(AGENT_SRC_DIR) META-INF/services/com.sun.jdi.connect.Connector
> 	$(QUIETLY) $(REMOTE) $(RUN.JAVAH) -classpath $(SA_CLASSDIR) -d $(GENERATED) -jni sun.jvm.hotspot.debugger.x86.X86ThreadContext
> 	$(QUIETLY) $(REMOTE) $(RUN.JAVAH) -classpath $(SA_CLASSDIR) -d $(GENERATED) -jni sun.jvm.hotspot.debugger.amd64.AMD64ThreadContext
> 	$(QUIETLY) $(REMOTE) $(RUN.JAVAH) -classpath $(SA_CLASSDIR) -d $(GENERATED) -jni sun.jvm.hotspot.debugger.sparc.SPARCThreadContext
>+	$(QUIETLY) $(REMOTE) $(RUN.JAVAH) -classpath $(SA_CLASSDIR) -d $(GENERATED) -jni sun.jvm.hotspot.debugger.ppc64.PPC64ThreadContext
> 	$(QUIETLY) $(REMOTE) $(RUN.JAVAH) -classpath $(SA_CLASSDIR) -d $(GENERATED) -jni sun.jvm.hotspot.asm.Disassembler
> 
> clean:
> 	rm -rf $(SA_CLASSDIR)
> 	rm -rf $(GENERATED)/sa-jdi.jar
> 	rm -rf $(AGENT_FILES_LIST)
>+
>+-include $(HS_ALT_MAKE)/bsd/makefiles/sa-rules.make
>--- ./hotspot/make/bsd/makefiles/saproc.make.orig
>+++ ./hotspot/make/bsd/makefiles/saproc.make
>@@ -99,10 +99,10 @@
> endif
> 
> # if $(AGENT_DIR) does not exist, we don't build SA
>-# also, we don't build SA on Itanium, PPC, ARM or zero.
>+# also, we don't build SA on Itanium, ARM or zero.
> 
> ifneq ($(wildcard $(AGENT_DIR)),)
>-ifneq ($(filter-out ia64 arm ppc zero,$(SRCARCH)),)
>+ifneq ($(filter-out ia64 arm zero,$(SRCARCH)),)
>   BUILDLIBSAPROC = $(LIBSAPROC)
> endif
> endif
>@@ -162,16 +162,17 @@
> endif
> 
> install_saproc: $(BUILDLIBSAPROC)
>-	@echo "Copying $(LIBSAPROC) to $(DEST_SAPROC)"
>+	$(QUIETLY) if [ -e $(LIBSAPROC) ] ; then             \
>+	  echo "Copying $(LIBSAPROC) to $(DEST_SAPROC)";     \
> ifeq ($(OS_VENDOR), Darwin)
>-	$(QUIETLY) test -d $(LIBSAPROC_DEBUGINFO) && \
>-	    cp -f -r $(LIBSAPROC_DEBUGINFO) $(DEST_SAPROC_DEBUGINFO)
>+	$test -d $(LIBSAPROC_DEBUGINFO) && 			\
>+	    cp -f -r $(LIBSAPROC_DEBUGINFO) $(DEST_SAPROC_DEBUGINFO); \
> else
>-	$(QUIETLY) test -f $(LIBSAPROC_DEBUGINFO) && \
>-	    cp -f $(LIBSAPROC_DEBUGINFO) $(DEST_SAPROC_DEBUGINFO)
>+	 test -f $(LIBSAPROC_DEBUGINFO) && 		\
>+	    cp -f $(LIBSAPROC_DEBUGINFO) $(DEST_SAPROC_DEBUGINFO);   \
> endif
>-	$(QUIETLY) test -f $(LIBSAPROC_DIZ) && \
>-	    cp -f $(LIBSAPROC_DIZ) $(DEST_SAPROC_DIZ)
>-	$(QUIETLY) cp -f $(LIBSAPROC) $(DEST_SAPROC) && echo "Done"
>+	 test -f $(LIBSAPROC_DIZ) && 				\
>+	    cp -f $(LIBSAPROC_DIZ) $(DEST_SAPROC_DIZ); \
>+	 cp -f $(LIBSAPROC) $(DEST_SAPROC) && echo "Done"
> 
> .PHONY: install_saproc
>--- ./hotspot/make/sa.files
>+++ ./hotspot/make/sa.files
>@@ -45,22 +45,27 @@
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/amd64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/bsd/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/bsd/amd64/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/bsd/ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/bsd/x86/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/cdbg/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/cdbg/basic/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/dummy/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/linux/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/linux/amd64/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/linux/ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/linux/x86/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/linux/sparc/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/posix/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/posix/elf/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/proc/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/proc/amd64/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/proc/ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/proc/sparc/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/proc/x86/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/remote/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/remote/amd64/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/remote/ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/remote/sparc/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/remote/x86/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/debugger/sparc/*.java \
>@@ -85,17 +90,20 @@
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/amd64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/bsd/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/bsd_amd64/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/bsd_ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/bsd_x86/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/linux/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/linux_amd64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/linux_x86/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/linux_sparc/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/linux_ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/posix/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/solaris_amd64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/solaris_sparc/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/solaris_x86/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/sparc/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/x86/*.java \
>+$(AGENT_SRC_DIR)/sun/jvm/hotspot/runtime/ppc64/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/tools/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/tools/jcore/*.java \
> $(AGENT_SRC_DIR)/sun/jvm/hotspot/tools/soql/*.java \
> --- ./hotspot/make/bsd/makefiles/defs.make.orig
>+++ ./hotspot/make/bsd/makefiles/defs.make
>@@ -352,7 +352,7 @@
> endif
> 
> # Serviceability Binaries
>-# No SA Support for PPC, IA64, ARM or zero
>+# No SA Support for IA64, ARM or zero
> ADD_SA_BINARIES/x86   = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
>                         $(EXPORT_LIB_DIR)/sa-jdi.jar
> 
>@@ -368,6 +368,23 @@
>   endif
> endif
> 
>+ADD_SA_BINARIES/ppc   = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
>+                        $(EXPORT_LIB_DIR)/sa-jdi.jar
>+ADD_SA_BINARIES/universal = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
>+                            $(EXPORT_LIB_DIR)/sa-jdi.jar
>+
>+ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
>+  ifeq ($(ZIP_DEBUGINFO_FILES),1)
>+      ADD_SA_BINARIES/ppc += $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.diz
>+  else
>+    ifeq ($(OS_VENDOR), Darwin)
>+        ADD_SA_BINARIES/ppc += $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX).dSYM
>+    else
>+        ADD_SA_BINARIES/ppc += $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.debuginfo
>+    endif
>+  endif
>+endif
>+
> ADD_SA_BINARIES/sparc = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
>                         $(EXPORT_LIB_DIR)/sa-jdi.jar
> ADD_SA_BINARIES/universal = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
>@@ -385,7 +400,6 @@
>   endif
> endif
> 
>-ADD_SA_BINARIES/ppc   =
> ADD_SA_BINARIES/ia64  =
> ADD_SA_BINARIES/arm   =
> ADD_SA_BINARIES/zero  =

Actions: View

Attachments on bug 212709: 174808 | 178386