public inbox for frysk-cvs@sourceware.org
help / color / mirror / Atom feed
* [SCM]  master: Simplify LocalMemory.
@ 2008-05-06 16:01 cagney
  0 siblings, 0 replies; only message in thread
From: cagney @ 2008-05-06 16:01 UTC (permalink / raw)
  To: frysk-cvs

The branch, master has been updated
       via  361c5e7e7ce9443a28b9dd739eadb655f754c40a (commit)
       via  b10322b95907790a26ae0e458e0fd7f266dd82d0 (commit)
      from  f8f7eaf688fc72459c066fa89d2734ced3a865d8 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email.

- Log -----------------------------------------------------------------
commit 361c5e7e7ce9443a28b9dd739eadb655f754c40a
Author: Andrew Cagney <cagney@redhat.com>
Date:   Tue May 6 11:53:11 2008 -0400

    Simplify LocalMemory.
    
    frysk-sys/frysk/testbed/ChangeLog
    2008-05-06  Andrew Cagney  <cagney@redhat.com>
    
    	* LocalMemory.java (dataByte, dataShort, dataInt, dataLong):
    	Delete.
    	* cni/LocalMemory.cxx: Update.
    	* TestLocalMemory.java: Update.

commit b10322b95907790a26ae0e458e0fd7f266dd82d0
Author: Andrew Cagney <cagney@redhat.com>
Date:   Tue May 6 11:01:24 2008 -0400

    Add <Type>Array methods to jnixx.hxx.
    
    2008-05-06  Andrew Cagney  <cagney@redhat.com>
    
    	* jnixx.hxx (jnixx::env): Add <Type>Array methods.
    	* PrintDefinitions.java: Don't cast primitive array results.

-----------------------------------------------------------------------

Summary of changes:
 frysk-sys/frysk/jnixx/ChangeLog              |    5 +
 frysk-sys/frysk/jnixx/PrintDefinitions.java  |    6 +-
 frysk-sys/frysk/jnixx/jnixx.hxx              |  134 ++++++++++++++++++++++++++
 frysk-sys/frysk/testbed/ChangeLog            |    7 ++
 frysk-sys/frysk/testbed/LocalMemory.java     |   44 ++-------
 frysk-sys/frysk/testbed/TestLocalMemory.java |    9 +--
 frysk-sys/frysk/testbed/cni/LocalMemory.cxx  |   77 +++++++--------
 7 files changed, 198 insertions(+), 84 deletions(-)

First 500 lines of diff:
diff --git a/frysk-sys/frysk/jnixx/ChangeLog b/frysk-sys/frysk/jnixx/ChangeLog
index 62bb250..b38a94c 100644
--- a/frysk-sys/frysk/jnixx/ChangeLog
+++ b/frysk-sys/frysk/jnixx/ChangeLog
@@ -1,3 +1,8 @@
+2008-05-06  Andrew Cagney  <cagney@redhat.com>
+
+	* jnixx.hxx (jnixx::env): Add <Type>Array methods.
+	* PrintDefinitions.java: Don't cast primitive array results.
+
 2008-05-05  Andrew Cagney  <cagney@redhat.com>
 
 	* jnixx.hxx (jnixx::object): New.
diff --git a/frysk-sys/frysk/jnixx/PrintDefinitions.java b/frysk-sys/frysk/jnixx/PrintDefinitions.java
index 9aaf230..a57a607 100644
--- a/frysk-sys/frysk/jnixx/PrintDefinitions.java
+++ b/frysk-sys/frysk/jnixx/PrintDefinitions.java
@@ -286,7 +286,11 @@ class PrintDefinitions implements ClassWalker {
 		    } else if (returnType == String.class) {
 			p.print("(jstring) ret._object");
 		    } else if (returnType.isArray()) {
-			p.print("(jobjectArray) ret._object");
+			if (returnType.getComponentType().isPrimitive()) {
+			    p.print("ret");
+			} else {
+			    p.print("(jobjectArray) ret._object");
+			}
 		    } else {
 			p.print("ret._object");
 		    }
diff --git a/frysk-sys/frysk/jnixx/jnixx.hxx b/frysk-sys/frysk/jnixx/jnixx.hxx
index 52e6658..000c038 100644
--- a/frysk-sys/frysk/jnixx/jnixx.hxx
+++ b/frysk-sys/frysk/jnixx/jnixx.hxx
@@ -430,6 +430,140 @@ public:
       throw jnixx::exception();
   }
 
+  jobjectArray newObjectArray(jsize length, jclass elementType,
+			 jobject initialElement) {
+    jobjectArray tmp = jniEnv->NewObjectArray(length, elementType, initialElement);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jbooleanArray newBooleanArray(jsize length) {
+    jbooleanArray tmp = jniEnv->NewBooleanArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jbyteArray newByteArray(jsize length) {
+    jbyteArray tmp = jniEnv->NewByteArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jcharArray newCharArray(jsize length) {
+    jcharArray tmp = jniEnv->NewCharArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jshortArray newShortArray(jsize length) {
+    jshortArray tmp = jniEnv->NewShortArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jintArray newIntArray(jsize length) {
+    jintArray tmp = jniEnv->NewIntArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jlongArray newLongArray(jsize length) {
+    jlongArray tmp = jniEnv->NewLongArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jfloatArray newFloatArray(jsize length) {
+    jfloatArray tmp = jniEnv->NewFloatArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jdoubleArray newDoubleArray(jsize length) {
+    jdoubleArray tmp = jniEnv->NewDoubleArray(length);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+
+  jsize getArrayLength(jarray array) {
+    return jniEnv->GetArrayLength(array);
+  }
+
+  jboolean* getBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
+    jboolean* tmp = jniEnv->GetBooleanArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jbyte* getByteArrayElements(jbyteArray array, jboolean *isCopy) {
+    jbyte* tmp = jniEnv->GetByteArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jchar* getCharArrayElements(jcharArray array, jboolean *isCopy) {
+    jchar* tmp = jniEnv->GetCharArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jshort* getShortArrayElements(jshortArray array, jboolean *isCopy) {
+    jshort* tmp = jniEnv->GetShortArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jint* getIntArrayElements(jintArray array, jboolean *isCopy) {
+    jint* tmp = jniEnv->GetIntArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jlong* getLongArrayElements(jlongArray array, jboolean *isCopy) {
+    jlong* tmp = jniEnv->GetLongArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jfloat* getFloatArrayElements(jfloatArray array, jboolean *isCopy) {
+    jfloat* tmp = jniEnv->GetFloatArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+  jdouble* getDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
+    jdouble* tmp = jniEnv->GetDoubleArrayElements(array, isCopy);
+    if (tmp == NULL)
+      throw jnixx::exception();
+    return tmp;
+  }
+
+  void releaseBooleanArrayElements(jbooleanArray array, jboolean* elements, jint mode) {
+    jniEnv->ReleaseBooleanArrayElements(array, elements, mode);
+  }
+  void releaseByteArrayElements(jbyteArray array, jbyte* elements, jint mode) {
+    jniEnv->ReleaseByteArrayElements(array, elements, mode);
+  }
+  void releaseCharArrayElements(jcharArray array, jchar* elements, jint mode) {
+    jniEnv->ReleaseCharArrayElements(array, elements, mode);
+  }
+  void releaseShortArrayElements(jshortArray array, jshort* elements, jint mode) {
+    jniEnv->ReleaseShortArrayElements(array, elements, mode);
+  }
+  void releaseIntArrayElements(jintArray array, jint* elements, jint mode) {
+    jniEnv->ReleaseIntArrayElements(array, elements, mode);
+  }
+  void releaseLongArrayElements(jlongArray array, jlong* elements, jint mode) {
+    jniEnv->ReleaseLongArrayElements(array, elements, mode);
+  }
+  void releaseFloatArrayElements(jfloatArray array, jfloat* elements, jint mode) {
+    jniEnv->ReleaseFloatArrayElements(array, elements, mode);
+  }
+  void releaseDoubleArrayElements(jdoubleArray array, jdouble* elements, jint mode) {
+    jniEnv->ReleaseDoubleArrayElements(array, elements, mode);
+  }
+
   void callVoidMethod(jobject object, jmethodID id, ...) {
     va_list ap;
     va_start(ap, id);
diff --git a/frysk-sys/frysk/testbed/ChangeLog b/frysk-sys/frysk/testbed/ChangeLog
index e11dedc..38a81a1 100644
--- a/frysk-sys/frysk/testbed/ChangeLog
+++ b/frysk-sys/frysk/testbed/ChangeLog
@@ -1,3 +1,10 @@
+2008-05-06  Andrew Cagney  <cagney@redhat.com>
+
+	* LocalMemory.java (dataByte, dataShort, dataInt, dataLong):
+	Delete.
+	* cni/LocalMemory.cxx: Update.
+	* TestLocalMemory.java: Update.
+
 2008-04-11  Andrew Cagney  <cagney@redhat.com>
 
 	* jni/LocalMemory.cxx: New.
diff --git a/frysk-sys/frysk/testbed/LocalMemory.java b/frysk-sys/frysk/testbed/LocalMemory.java
index c5902bf..633a151 100644
--- a/frysk-sys/frysk/testbed/LocalMemory.java
+++ b/frysk-sys/frysk/testbed/LocalMemory.java
@@ -39,56 +39,34 @@
 
 package frysk.testbed;
 
-import frysk.rsl.Log;
+/**
+ * Provide access to known local areas of memory.
+ *
+ * Most useful by doing a fork to create a mirror image of the address
+ * space that can then be manipulated using ptrace calls.
+ */
 
 public class LocalMemory {
-    private static final Log fine = Log.fine(LocalMemory.class);
-
-    /**
-     * Known memory values.
-     */
-     public static final byte byteData = 43;
-     public static final short shortData = 45;
-     public static final int intData = 42;
-     public static final long longData = 44;
-
-    public static final int SIZE = 32;
-
     /**
-     * Returns the address of a variable for inspection.
+     * Returns the address of a bunch of data.
      */
-    public static native long getByteDataAddr();
-    public static native long getShortDataAddr();
-    public static native long getIntDataAddr();
-    public static native long getLongDataAddr();
-
-    private static native byte[] getBytes(long addr, int bytes);
+    public static native long getDataAddr();
 
     /**
-     * Returns the address of the variables.
-     */
-    public static native long getDataAddr ();
-    /**
      * Returns a copy of SIZE data bytes starting at getDataAddr.
      */
-    public static byte[] getDataBytes () {
-	fine.log("getDataBytes", getDataAddr(), "size", SIZE);
-	return getBytes(getDataAddr(), SIZE);
-    }
+    public static native byte[] getDataBytes();
 
     /**
      * Returns the address of a function.
      */
     public static native long getCodeAddr();
+
     /*
      * Returns a copy of SIZE instruction bytes starting at
      * getCodeAddr().
      */
-    public static byte[] getCodeBytes() {
-	fine.log("getCodeBytes", getCodeAddr(), "size", SIZE);
-	return getBytes(getCodeAddr(), SIZE);
-    }
-
+    public static native byte[] getCodeBytes();
 
     /**
      * Returns the line number of a function.
diff --git a/frysk-sys/frysk/testbed/TestLocalMemory.java b/frysk-sys/frysk/testbed/TestLocalMemory.java
index 5316f51..f378d55 100644
--- a/frysk-sys/frysk/testbed/TestLocalMemory.java
+++ b/frysk-sys/frysk/testbed/TestLocalMemory.java
@@ -94,13 +94,6 @@ public class TestLocalMemory
      */
     public void testDataContents() {
 	byte[] bytes = LocalMemory.getDataBytes();
-	assertEquals("data byte[0]", LocalMemory.byteData, bytes[0]);
-    }
-    /**
-     * Check the data addresses have the expected offsets.
-     */
-    public void testDataAddresses() {
-	assertEquals("byteData address", LocalMemory.getDataAddr(),
-		     LocalMemory.getByteDataAddr());
+	assertEquals("data byte[0]", 43, bytes[0]);
     }
 }
diff --git a/frysk-sys/frysk/testbed/cni/LocalMemory.cxx b/frysk-sys/frysk/testbed/cni/LocalMemory.cxx
index 8e5c9b3..6eef06c 100644
--- a/frysk-sys/frysk/testbed/cni/LocalMemory.cxx
+++ b/frysk-sys/frysk/testbed/cni/LocalMemory.cxx
@@ -46,40 +46,28 @@
 #include "frysk/testbed/LocalMemory.h"
 #include "frysk/testbed/LocalMemory$StackBuilder.h"
 
-jlong
-frysk::testbed::LocalMemory::getByteDataAddr ()
-{
-  return (jlong) &byteData;
-}
-jlong
-frysk::testbed::LocalMemory::getShortDataAddr ()
-{
-  return (jlong) &shortData;
-}
-jlong
-frysk::testbed::LocalMemory::getIntDataAddr ()
-{
-  return (jlong) &intData;
-}
-jlong
-frysk::testbed::LocalMemory::getLongDataAddr ()
-{
-  return (jlong) &longData;
+static jbyteArray
+getBytes(void *addr, size_t length) {
+  jbyteArray bytes = JvNewByteArray(length);
+  memcpy(elements (bytes), addr, length);
+  return bytes;
 }
 
+struct m {
+  jbyte byteData;
+  jshort shortData;
+  jint intData;
+  jlong longData;
+} memory = { 43, 45, 42, 44 };
+
 jlong
-frysk::testbed::LocalMemory::getDataAddr ()
-{
-  return (jlong) &byteData;
+frysk::testbed::LocalMemory::getDataAddr() {
+  return (jlong) &memory;
 }
 
 jbyteArray
-frysk::testbed::LocalMemory::getBytes (jlong addr, jint length)
-{
-  uint8_t *start = (uint8_t*)addr;
-  jbyteArray bytes = JvNewByteArray (length);
-  memcpy (elements (bytes), start, bytes->length);
-  return bytes;
+frysk::testbed::LocalMemory::getDataBytes() {
+  return getBytes(&memory, sizeof(memory));
 }
 
 /**
@@ -89,28 +77,33 @@ frysk::testbed::LocalMemory::getBytes (jlong addr, jint length)
 jint frysk::testbed::LocalMemory::getCodeLine () { return __LINE__; }
 
 jstring
-frysk::testbed::LocalMemory::getCodeFile ()
-{
+frysk::testbed::LocalMemory::getCodeFile() {
   return JvNewStringUTF (__FILE__);
 }
 
-jlong
-frysk::testbed::LocalMemory::getCodeAddr ()
-{
+static void*
+codeAddr() {
 #ifdef __powerpc64__
-  return *((jlong*) frysk::testbed::LocalMemory::getCodeLine);
+  return *((void**) frysk::testbed::LocalMemory::getCodeLine);
 #else
-  return (jlong) frysk::testbed::LocalMemory::getCodeLine;
+  return (void*)&frysk::testbed::LocalMemory::getCodeLine;
 #endif
 }
+jlong
+frysk::testbed::LocalMemory::getCodeAddr() {
+  return (jlong)codeAddr();
+}
+
+jbyteArray
+frysk::testbed::LocalMemory::getCodeBytes() {
+  return getBytes(codeAddr(), sizeof(memory));
+}
 
 void
-frysk::testbed::LocalMemory::constructStack(frysk::testbed::LocalMemory$StackBuilder* builder)
-{
-  uint8_t addr[SIZE];
-  uint8_t *start = (uint8_t*)frysk::testbed::LocalMemory::getDataAddr();
-  // Copy the known data to the stack.
-  memcpy (addr, start, SIZE);
-  jbyteArray bytes = frysk::testbed::LocalMemory::getBytes((jlong)addr, SIZE);
+frysk::testbed::LocalMemory::constructStack(frysk::testbed::LocalMemory$StackBuilder* builder) {
+  // Copy known data onto the stack.
+  uint8_t addr[sizeof(memory)];
+  memcpy(addr, &memory, sizeof(memory));
+  jbyteArray bytes = getBytes(addr, sizeof(memory));
   builder->stack((jlong)addr, bytes);
 }


hooks/post-receive
--
frysk system monitor/debugger


^ permalink raw reply	[flat|nested] only message in thread

only message in thread, other threads:[~2008-05-06 16:01 UTC | newest]

Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2008-05-06 16:01 [SCM] master: Simplify LocalMemory cagney

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).