gprofng: a new GNU profiler

top-level
	* Makefile.def: Add gprofng module.
	* configure.ac: Add --enable-gprofng option.
	* src-release.sh: Add gprofng.
	* Makefile.in: Regenerate.
	* configure: Regenerate.
	* gprofng: New directory.

binutils
	* MAINTAINERS: Add gprofng maintainer.
	* README-how-to-make-a-release: Add gprofng.

include.
	* collectorAPI.h: New file.
	* libcollector.h: New file.
	* libfcollector.h: New file.

9 files changed, 880 insertions, 0 deletions

diff --git a/gprofng/testsuite/gprofng.display/jsynprog/Intface.java b/gprofng/testsuite/gprofng.display/jsynprog/Intface.java
new file mode 100644
index 0000000..016e7b2
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/Intface.java
@@ -0,0 +1,6 @@
+//   Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
+
+public interface Intface {
+   public int add_int (int scale);
+   public double add_double (int scale);
+}
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/Launcher.java b/gprofng/testsuite/gprofng.display/jsynprog/Launcher.java
new file mode 100644
index 0000000..33ee06c
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/Launcher.java
@@ -0,0 +1,90 @@
+// Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
+// @(#)Launcher.java 1.3 10/03/24 SMI
+
+import java.lang.reflect.*;
+
+public class Launcher {
+// Byte array for dynamically loaded class:            //
+//public class DynLoadedClass {                        //
+//   public int DynamicFunction(int x) {               //
+//      float f = 0;                                   //
+//      for (int k=0 ; k<20000; k++) {                 //
+//         f =  ((float)k) / x;                        //
+//      }                                              //
+//      return (int)f;                                 //
+//   }                                                 //
+//                                                     //
+//    public static void main(String[] args){          //
+//        DynLoadedClass dcls = new DynLoadedClass();  //
+//        for (int k=0 ; k<10; k++) {                  //
+//            dcls.DynamicFunction(k);                 //
+//        }                                            //
+//    }                                                //
+//}                                                    //
+static final byte [] bClassGenerated = {
+        -54, -2, -70, -66, 0, 0, 0, 46, 0, 20, 10, 0, 5, 0, 16, 7, 0, 17, 10, 0, 2, 0, 16, 10, 0, 2, 
+        0, 18, 7, 0, 19, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 
+        100, 101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0, 15, 68, 121, 
+        110, 97, 109, 105, 99, 70, 117, 110, 99, 116, 105, 111, 110, 1, 0, 4, 40, 73, 41, 73, 1, 0, 4, 109, 97, 
+        105, 110, 1, 0, 22, 40, 91, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 
+        41, 86, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, 0, 19, 68, 121, 110, 76, 111, 97, 100, 
+        101, 100, 67, 108, 97, 115, 115, 46, 106, 97, 118, 97, 12, 0, 6, 0, 7, 1, 0, 14, 68, 121, 110, 76, 111, 
+        97, 100, 101, 100, 67, 108, 97, 115, 115, 12, 0, 10, 0, 11, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 
+        103, 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, 2, 0, 5, 0, 0, 0, 0, 0, 3, 0, 1, 0, 6, 0, 
+        7, 0, 1, 0, 8, 0, 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0, 
+        1, 0, 9, 0, 0, 0, 6, 0, 1, 0, 0, 0, 1, 0, 1, 0, 10, 0, 11, 0, 1, 0, 8, 0, 0, 
+        0, 66, 0, 2, 0, 4, 0, 0, 0, 26, 11, 69, 3, 62, 29, 17, 78, 32, -94, 0, 15, 29, -122, 27, -122, 
+        110, 69, -124, 3, 1, -89, -1, -16, 36, -117, -84, 0, 0, 0, 1, 0, 9, 0, 0, 0, 22, 0, 5, 0, 0, 
+        0, 3, 0, 2, 0, 4, 0, 11, 0, 5, 0, 17, 0, 4, 0, 23, 0, 7, 0, 9, 0, 12, 0, 13, 0, 
+        1, 0, 8, 0, 0, 0, 69, 0, 2, 0, 3, 0, 0, 0, 29, -69, 0, 2, 89, -73, 0, 3, 76, 3, 61, 
+        28, 16, 10, -94, 0, 15, 43, 28, -74, 0, 4, 87, -124, 2, 1, -89, -1, -15, -79, 0, 0, 0, 1, 0, 9, 
+        0, 0, 0, 22, 0, 5, 0, 0, 0, 11, 0, 8, 0, 12, 0, 16, 0, 13, 0, 22, 0, 12, 0, 28, 0, 
+        15, 0, 1, 0, 14, 0, 0, 0, 2, 0, 15
+    };
+    
+    private static DynClassLoader persistentInstance;
+    
+    public static DynClassLoader getPersistentInstance()
+    {
+        if (persistentInstance == null)
+            persistentInstance = new DynClassLoader();
+        return persistentInstance;
+    }	
+
+    public static void main(String args []) {
+        if (args.length != 1) {
+	    System.err.println("Usage: Launcher DynLoadedClass");
+	    return;
+	}
+
+        String className = args[0]; // Dynamic class name
+
+        try {
+            Class    genClass  = getPersistentInstance().getClassFromByteArray(className, bClassGenerated);
+            Method[] methods_g = genClass.getDeclaredMethods();
+
+            for (int i = 0; i < methods_g.length; i++) {
+                Method m = methods_g[i];
+                String methodName = m.getName();
+		String progArgs[] = new String[1];
+		//System.out.println("Invoking method " + className + "." + methodName);
+		if (methodName.equals("main"))
+		    m.invoke( null, (Object[]) progArgs );
+            }
+        } catch (InvocationTargetException iex) {
+            System.err.println("InvocationTargetException");
+        } catch (IllegalAccessException aex) {
+            System.err.println("IllegalAccessException");
+        }
+    }
+
+    // Class loader to generate dynamic class on the fly from the byte array
+    private static class DynClassLoader extends ClassLoader {
+        public DynClassLoader() { }
+        public Class getClassFromByteArray(String name, byte[] b) {
+            return super.defineClass(name, b, 0, b.length);
+        }
+    }
+
+
+}
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/Makefile b/gprofng/testsuite/gprofng.display/jsynprog/Makefile
new file mode 100644
index 0000000..e78b692
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/Makefile
@@ -0,0 +1,56 @@
+#   Copyright (C) 2021 Free Software Foundation, Inc.
+#
+# This file is part of the GNU Binutils.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program 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 for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+TARGETS     = libcloop.so jsynprog.class
+TARGET      = jsynprog
+ACCT_FILE   = jsynprog.acct
+
+srcdir = .
+include $(srcdir)/../../lib/Makefile.skel
+
+JAVACFLAGS  =
+
+SRCS = \
+	$(srcdir)/../mttest/gethrtime.c \
+	$(srcdir)/cloop.cc \
+	$(NULL)
+
+JAVA_SRCS = \
+	$(srcdir)/Intface.java \
+	$(srcdir)/Routine.java \
+	$(srcdir)/Sub_Routine.java \
+	$(srcdir)/jsynprog.java \
+	$(srcdir)/Launcher.java \
+	$(NULL)
+
+HDRS = jsynprog.h
+
+libcloop.so: $(SRCS) 
+	@echo " ---- Build: $@ -----"
+	$(CC) $(jdk_inc) $(CCOPTS) $(SHAREDOPT) -o $@ $(SRCS)
+
+jsynprog.class: $(JAVA_SRCS)
+	@echo " ---- Build: $@ -----"
+	$(JAVAC) $(JAVACFLAGS) -d . $(JAVA_SRCS)
+
+$(EXPERIMENT): $(TARGETS)
+	@echo " ---- Build: $@ -----"
+	rm -rf $@ 
+	$(COLLECT) $(COLLECT_FLAGS) -o $@ $(JAVA) $(JAVACFLAGS) jsynprog
+
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/Routine.java b/gprofng/testsuite/gprofng.display/jsynprog/Routine.java
new file mode 100644
index 0000000..cfe45d2
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/Routine.java
@@ -0,0 +1,224 @@
+/**
+ *   Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
+ * This class implements the Intface interface
+ * increments value of integer and floats
+ */
+
+import java.util.*;
+
+public class Routine implements Intface {
+
+   /* add integers */
+   public int add_int (int scale) {
+	int 	x = 0;
+	int kmax = 100*scale;
+	double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	do { x = 0;
+	for (int k=0; k<kmax;k++) {
+	   for (int j=0; j<10000;j++) {
+		x = x + 1;
+	   }
+	}
+	} while (jsynprog.Timer() < tEnd);
+	return x;
+   }
+
+  /* add double */
+  public double add_double (int scale) {
+	double	y = 0.0;
+	int kmax = 1*scale;
+	double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	do { y = 0.0;
+	for (int k=0; k<kmax;k++) {
+	   for (int j=0; j<10000;j++) {
+		y = y + 1.0;
+	   }
+	}
+	} while (jsynprog.Timer() < tEnd);
+	return y;
+   }
+
+  /* Use inner class */
+  public Integer[] has_inner_class(int scale) {
+	class JInner {
+	    Integer[] g_int = new Integer[3];
+     
+	    public Integer[] buildlist(int scale) {
+		double tEnd = jsynprog.Timer() + jsynprog.testtime;
+		do {
+		for (int k=0; k<g_int.length; k++) {
+		    int 	x = 0;
+		    int imax = 10*scale;
+		    for (int i=0; i<imax;i++) {
+			for (int j=0; j<10000;j++) {
+			    x = x + 1;
+			}
+		    }
+		    g_int[k]=new Integer (x); 
+		 } 
+		 } while (jsynprog.Timer() < tEnd);
+		 return g_int;
+	    }
+	}
+	return ((new JInner()).buildlist(scale));
+  }
+
+  public void memalloc (int nsize, int scale) {
+	class myobj {
+	    int nitem;
+	    String shape;
+	    String color;
+
+	    myobj() { 
+		  nitem = 4;
+		  shape = "square";
+		  color = "blue";
+	    }
+	}
+	for (int j=0; j<60; j++) {
+	   for (int i=0; i<20; i++) {
+		myobj[] blueobj = new myobj[1000000]; 
+	   }
+	}
+  } 
+
+  /* routine to do recursion */
+  public void recurse(int i, int imax, int scale) {
+     if(i == imax) {
+	double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	do {
+	    double x;
+	    int j, k;
+	    x = 0.0;
+	    for(k=0; k<scale; k++) {
+		   for(j=0; j<5000000; j++) {
+			  x = x + 1.0;
+		   }
+	    }
+	} while (jsynprog.Timer() < tEnd);
+     } else {
+	    recurse(i+1, imax, scale);
+     }
+  }
+
+  /* routine to do deep recursion */
+  public void recursedeep(int i, int imax, int scale) {
+     if(i == imax) {
+	  double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	  do {
+	    double x;
+	    int j, k;
+	    x = 0.0;
+	    for(k=0; k<scale; k++) {
+		   for(j=0; j<5000000; j++) {
+			  x = x + 1.0;
+		   }
+	    }
+	  } while (jsynprog.Timer() < tEnd);
+     } else {
+	    recursedeep(i+1, imax, scale);
+     }
+  }
+
+
+  /* bounce -- example of indirect recursion */
+  public void bounce(int i, int imax, int scale) {
+	if(i == imax) {
+	  double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	  do {
+	     double x;
+	     int j, k;
+		x = 0.0;
+		for(k=0; k < scale; k++) {
+		    for(j=0; j<5000000; j++) {
+			   x = x + 1.0;
+		    }
+		}
+	  } while (jsynprog.Timer() < tEnd);
+	} else {
+		bounce_b(i, imax, scale);
+	}
+  }
+
+  private void bounce_b(int i, int imax, int scale) {
+	bounce(i+1, imax, scale);
+	return;
+  }
+
+
+  /* large array */ 
+  public void array_op(int scale) {
+	int size = 50000;
+	int imax = 1*scale;
+	Integer[] y = allocate_array(3*size);
+	Integer[] z = allocate_array(size);
+	double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	do {
+	for (int i=0; i<imax; i++) {
+	    System.arraycopy(y, 2, z, 0, size);
+	}
+	} while (jsynprog.Timer() < tEnd);
+  }   
+  
+  /* define large array */ 
+  private Integer[] allocate_array(int num) {
+	Integer[] x = new Integer[num];
+	for (int i=0; i<num;i++) {
+	    x[i] = new Integer(i);
+	}
+	return x;
+  }   
+
+
+  /* large vector */
+  public void vector_op(int scale) {
+	Vector v = allocate_vector(); 
+	int imax = 1*scale;
+	int jmax = 1*scale;
+	double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	do {
+	for (int i=0; i<imax; i++) {
+	    vrem_last(v);
+	}
+	for (int j=0; j<jmax; j++) {
+	    vrem_first(v);
+	}
+	} while (jsynprog.Timer() < tEnd);
+  }   
+
+  /* define large Vector */ 
+  private Vector allocate_vector() {
+	Vector<Integer> v1 = new Vector<Integer> (200000);
+	for (int i=0; i<1000000;i++) {
+	    v1.add(new Integer(i)); 
+	}
+	return v1;
+  }
+ 
+  /* remove last element of vector */ 
+  private void vrem_last(Vector v) {
+	v.remove(v.size()-1);
+  }
+
+  /* remove first element of vector */ 
+  private void vrem_first(Vector v) {
+	v.remove(0);
+  }
+
+
+  /* Spend time in system calls */
+  public void sys_op(int scale) {
+	long stime ;
+	int jmax = 1000000;
+	int imax = 4;
+	double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	do {
+	for (int i = 0; i < imax; i++) {
+	    for(int j=0; j<jmax; j++) {
+		  stime = System.currentTimeMillis();
+	    }
+	}
+	} while (jsynprog.Timer() < tEnd);
+  }
+
+} //end of class
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/Sub_Routine.java b/gprofng/testsuite/gprofng.display/jsynprog/Sub_Routine.java
new file mode 100644
index 0000000..11e045e
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/Sub_Routine.java
@@ -0,0 +1,54 @@
+/* Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
+** @(#)Sub_Routine.java 1.4 10/03/24 SMI
+** This is subclass of Routine , overrides one method
+*/
+
+public class Sub_Routine extends Routine {
+    private static native double cTimer();
+
+   /*
+    ** Calls another method c() many times, overridden methos
+    */
+   public int add_int(int scale) {
+	int w = 0;
+	int kmax = 100*scale;
+        if (scale == 1) {
+           kmax /= 100;
+        }
+	double tEnd = jsynprog.Timer() + jsynprog.testtime;
+	do { w = 0;
+	for (int k=0 ; k<kmax; k++) {
+	    w = addcall(w) + 1;
+	}
+	} while (jsynprog.Timer() < tEnd);
+	return w;
+   }
+
+   private static int addcall(int x) {
+	int jmax = 100;
+        int imax = 10;
+	for (int j=0; j<jmax;j++) {
+            for (int i=0; i<imax; i++) {
+	        x = (i%2==0)?x:(x + 1);
+            }
+	}
+	return x;
+   }
+
+   public int naptime(int k, int scale)
+   {
+	int i;
+	int imax = k * scale;
+
+	try {
+	    for (i = 0; i < imax; i++) {
+		System.out.println(i + " sleeping");
+		Thread.currentThread().sleep(10);
+		i=i+1;  
+	    }
+	} catch (InterruptedException e) {e.printStackTrace();}
+	System.out.println("In naptime");
+	return 0;
+   }
+
+}
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/check_results.pl b/gprofng/testsuite/gprofng.display/jsynprog/check_results.pl
new file mode 100755
index 0000000..eac58a2
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/check_results.pl
@@ -0,0 +1,33 @@
+#!/bin/sh -- # This comment tells perl not to loop!
+
+#   Copyright (C) 2021 Free Software Foundation, Inc.
+#
+# This file is part of the GNU Binutils.
+#
+# This file is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program 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 for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
+# MA 02110-1301, USA.
+
+eval 'exec ${PERL:=/usr/dist/exe/perl} -S $0 ${1+"$@"}'
+if 0;
+
+use strict;
+require "acct.pm";
+
+my(@checkTime) = (1, 2);
+acct::readAcct($ARGV[0], @checkTime);
+acct::read_er_print_out($ARGV[1], -1);
+acct::createDiff();
+exit acct::set_retVal(0);
+
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/cloop.cc b/gprofng/testsuite/gprofng.display/jsynprog/cloop.cc
new file mode 100644
index 0000000..cf8b779
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/cloop.cc
@@ -0,0 +1,114 @@
+/*  
+ *      Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
+ */
+#include <jni.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include "jsynprog.h"
+
+typedef long long       hrtime_t;
+extern "C" {
+    hrtime_t gethrtime();
+    hrtime_t gethrvtime();
+}
+static jdouble testtime = 3.0 * 1e9;
+
+int cfunc(int);
+
+JNIEXPORT jdouble JNICALL
+Java_jsynprog_Timer (JNIEnv *env, jclass obj)
+{
+    jdouble      jd;
+    hrtime_t     start;
+
+    start = gethrtime();
+    jd = (double)(start);
+    return jd;
+}
+
+JNIEXPORT jdouble JNICALL
+Java_jsynprog_cTimer (JNIEnv *env, jclass obj)
+{
+    jdouble      jd;
+    hrtime_t     vstart;
+
+    vstart = gethrvtime();
+    jd = (double)(vstart);
+    return jd;
+}
+
+JNIEXPORT jdouble JNICALL
+Java_jsynprog_computeSet (JNIEnv *env, jclass obj)
+{
+    char *s;
+
+    testtime = 3.0;
+    s = getenv("SP_COLLECTOR_TEST_TIMER");
+    if( s ) {
+        testtime = atof(s);
+        if (testtime < 1.0)
+            testtime = 1.0;
+    }
+    testtime *= 1e9;
+    return testtime;
+}
+
+JNIEXPORT jint JNICALL
+Java_jsynprog_JavaJavaC (JNIEnv *env, jclass obj, jint n, int scale )
+{
+    // fprintf(stderr, "Entering Java_jsynprog_JavaJavaC, scale = %d\n", scale);
+    int imax = 100000;
+    n = 0;
+    for (int i =0; i<imax; i++) {
+        n=n+((i%2==0)?1:2);
+    }
+    return n;
+}
+
+JNIEXPORT void JNICALL
+Java_jsynprog_JavaCC (JNIEnv *env, jclass obj, int scale)
+{
+    fprintf(stderr, "Entering Java_jsynprog_JavaCC, scale = %d\n", scale);
+    int n =0;
+    if (scale == 1) {
+        scale *= 1000;
+    }
+    int imax = 4*scale;
+    double tEnd = gethrtime() + testtime;
+    do { n = 0;
+    for (int i =0; i<imax; i++) {
+	n = cfunc(n);
+    }
+    } while (gethrtime() < tEnd);
+}
+
+int cfunc (int n) {
+    for (int j =0; j<100000;j++) {
+	n=n+1;
+    }
+    return n;
+}
+
+JNIEXPORT void JNICALL
+Java_jsynprog_JavaCJava (JNIEnv *env, jclass obj, int scale)
+{
+    fprintf(stderr, "Entering Java_jsynprog_JavaCJava, scale = %d\n", scale);
+    int pnum = 0;
+    jmethodID mid = (env)->GetStaticMethodID(obj, "javafunc", "(I)I");
+    if (mid == 0) {
+	fprintf(stderr, "Can't get jmethodID for \"javafunc\", \"(I)I\"\n");
+	return;
+    }
+    fprintf(stderr, "Calling CallStaticIntMethod, scale = %d\n", scale);
+    pnum = (env)->CallStaticIntMethod(obj, mid, scale);
+}
+
+JNIEXPORT jint JNICALL
+Java_jsynprog_isJVMPI (JNIEnv *env, jclass obj)
+{
+    char *jvmpi = getenv("SP_COLLECTOR_USE_JVMPI");
+
+    return jvmpi ? 1 : 0;
+}
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/jsynprog.h b/gprofng/testsuite/gprofng.display/jsynprog/jsynprog.h
new file mode 100644
index 0000000..34b4f6c
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/jsynprog.h
@@ -0,0 +1,74 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+/*  Copyright (c) 2006, 2011, Oracle and/or its affiliates. All Rights Reserved. */
+#include <jni.h>
+/* Header for class jsynprog */
+
+#ifndef _Included_jsynprog
+#define _Included_jsynprog
+#ifdef __cplusplus
+extern "C" {
+#endif
+/* Inaccessible static: dir_home */
+/* Inaccessible static: log */
+/* Inaccessible static: pstart */
+/* Inaccessible static: cstart */
+/*
+ * Class:     jsynprog
+ * Method:    Timer
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_jsynprog_Timer
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     jsynprog
+ * Method:    cTimer
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_jsynprog_cTimer
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     jsynprog
+ * Method:    computeSet
+ * Signature: ()D
+ */
+JNIEXPORT jdouble JNICALL Java_jsynprog_computeSet
+  (JNIEnv *, jclass);
+
+/*
+ * Class:     jsynprog
+ * Method:    JavaJavaC
+ * Signature: (I, I)I
+ */
+JNIEXPORT jint JNICALL Java_jsynprog_JavaJavaC
+  (JNIEnv *, jclass, jint, int);
+
+/*
+ * Class:     jsynprog
+ * Method:    JavaCC
+ * Signature: (I)V
+ */
+JNIEXPORT void JNICALL Java_jsynprog_JavaCC
+  (JNIEnv *, jclass, int);
+
+/*
+ * Class:     jsynprog
+ * Method:    JavaCJava
+ * Signature: (I, I)V
+ */
+JNIEXPORT void JNICALL Java_jsynprog_JavaCJava
+  (JNIEnv *, jclass, int);
+
+/*
+ * Class:     jsynprog
+ * Method:    isJVMPI
+ * Signature: (I)V
+ */
+JNIEXPORT jint JNICALL Java_jsynprog_isJVMPI
+  (JNIEnv *, jclass);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/gprofng/testsuite/gprofng.display/jsynprog/jsynprog.java b/gprofng/testsuite/gprofng.display/jsynprog/jsynprog.java
new file mode 100644
index 0000000..eb98b5e
--- /dev/null
+++ b/gprofng/testsuite/gprofng.display/jsynprog/jsynprog.java
@@ -0,0 +1,229 @@
+// Copyright (c) 2006, 2013, Oracle and/or its affiliates. All rights reserved.
+// @(#)jsynprog.java SMI
+
+import java.util.*;
+import java.io.*;
+import java.text.*;
+
+class jsynprog 
+{
+    private static String	dir_home;
+    private static PrintWriter	log;
+    private static double 	pstart, cstart;
+
+    /* JNI calls */
+    public  static native double Timer();
+    private static native double cTimer();
+    private static native double computeSet();
+    private static native int JavaJavaC(int np, int scale);
+    private static native void JavaCC(int scale);
+    private static native void JavaCJava(int scale);
+    private static native int isJVMPI();
+
+    public static double testtime = 3.0 * 1e9;
+
+    public static void main (String [] args)
+    {
+	jsynprog jsyn_obj = new jsynprog();
+	Integer ni;
+	int scale = 1000;
+
+	createAcct();
+	LoadJNILibrary(args);
+        testtime = computeSet();
+
+	/* check for invocation parameter */
+	if (args.length != 0) {
+	    if (args[0].equals("fast")) {
+		scale = 10000;
+	    } else if (args[0].equals("slow")) {
+		scale = 1;
+	    } else {
+		System.err.println("fatal: unexpected argument: " + args[0] );
+		System.exit(1);
+	    }
+	}
+
+	/* large memory allocations, trigger gc */
+	Routine rtn = new Routine();
+	Sub_Routine sbrt = new Sub_Routine();
+	recTime(); 
+	rtn.memalloc(10000, scale);
+	printValue("Routine.memalloc", false);
+
+	/* add integers */
+	recTime(); 
+	ni = new Integer (rtn.add_int(scale));
+	printValue("Routine.add_int", true);
+
+	/* add double */
+	recTime(); 
+	Double nd = new Double(rtn.add_double(scale)); 
+	printValue("Routine.add_double", true);
+
+	/* call method in derived class */ 
+	recTime(); 
+	ni = new Integer (sbrt.add_int(scale));
+	printValue("Sub_Routine.add_int", true);
+
+	/* call method that defines an inner class */ 
+	recTime(); 
+	Integer[] na = rtn.has_inner_class(scale);
+	printValue("Routine.has_inner_class", true);
+
+	/* recursion */ 
+	recTime(); 
+	rtn.recurse(0,80, scale);
+	printValue("Routine.recurse", true);
+
+	/* deep recursion */ 
+	recTime(); 
+	rtn.recursedeep(0,500, scale);
+	printValue("<Truncated-stack>", true);
+
+	/* indirect recursion */ 
+	recTime(); 
+	rtn.bounce(0,20, scale);
+	printValue("Routine.bounce", true);
+
+	/* array operations */ 
+	recTime(); 
+	rtn.array_op(scale);
+	printValue("Routine.array_op", false);
+
+	/* Vector operations */ 
+	recTime(); 
+	rtn.vector_op(scale);
+	printValue("Routine.vector_op", false);
+
+	/* spend time in system calls */ 
+	recTime(); 
+	rtn.sys_op(scale);
+	printValue("Routine.sys_op", false);
+
+	/* java->java->c */
+	recTime(); 
+	int np = 0;
+	jni_JavaJavaC(np, scale);
+	printValue("jsynprog.jni_JavaJavaC", true);
+
+	/* java->c->c */
+	recTime(); 
+	JavaCC(scale);
+	printValue("jsynprog.JavaCC", true);
+
+	/* java->c->java */
+	recTime(); 
+	JavaCJava(scale);
+	printValue("jsynprog.JavaCJava", true);
+     
+     
+	/* dynamically loaded classes */
+	String java_ver = System.getProperty("java.version");
+	Launcher lnch = new Launcher();
+	String[] params = new String[]{"DynLoadedClass"};
+	recTime();
+	lnch.main(params);
+	printValue("Launcher.main", true);
+
+	System.gc();
+   }
+
+   /* 
+    ** Create accounting file 
+    */
+   private static void createAcct() {
+	System.out.println ("Directing output to acct file...");
+	try {
+	   log = new PrintWriter (new FileWriter("jsynprog.acct"), true);
+	} catch (IOException ioe) {
+	   ioe.printStackTrace();
+	   System.err.println("fatal: Cannot create accounting file ");
+	   System.exit(1);
+	}
+
+	log.println("X\tLWPTime\tCPUTime\tFunction");
+   }
+
+   /* 
+    ** Print output in acct file 
+    */
+   private static void printValue (String fname, boolean noignore) {
+	double	p_end = Timer();	 // Global.Timer();
+	double	c_end = cTimer();	// Global.cTimer();
+	double	prog_elapsed = p_end - pstart;
+	double	cpu_elapsed = c_end - cstart;
+	DecimalFormat     format_decimal = new DecimalFormat("0.000");
+
+	System.out.println("Running " + fname + "; T = " + format_decimal.format(prog_elapsed * 0.000000001)
+		+" UCPU = " + format_decimal.format(cpu_elapsed * 0.000000001));
+	log.print( (noignore == true?  "X" : "Y")
+		+ "\t" + format_decimal.format(prog_elapsed * 0.000000001) + "\t"
+		+ format_decimal.format(cpu_elapsed * 0.000000001) + "\t");
+	log.println(fname);
+   }
+
+   /*
+    ** Record intial times
+    */
+   private static void recTime() {
+	pstart = Timer();	 // Global.Timer();
+	cstart = cTimer();	// Global.cTimer();
+   }
+
+   /*
+    ** Load dynamic shared library for JNI
+    */
+   private static void LoadJNILibrary(String[] args) {
+
+	try {
+	   dir_home = (new File(".")).getCanonicalPath();
+	} catch (IOException e) {
+	   dir_home = "..";
+	}
+	System.out.println("libpath:"+dir_home);
+
+	// Find which JVM was invoked
+	String jvm_format = System.getProperty("java.vm.name"); 
+	System.out.println("jvm "+ jvm_format);
+ 
+	try {
+	    System.out.println("Loading library.... " + dir_home + "/libcloop.so");
+	    System.load(dir_home + "/libcloop.so");
+	} catch (UnsatisfiedLinkError e) {
+	   System.err.println("fatal: Cannot load shared library " + e);
+	   System.exit(1);
+	}
+   }
+
+   /*
+    ** Makes a lot of JNI calls
+    */ 
+   private static void jni_JavaJavaC(int np, int scale) {
+	int ret = 0;
+	int jmax = 10000;
+	System.out.println("Entering jni_JavaJavaC, scale = " + scale);
+	double tEnd = Timer() + testtime;
+	do {
+	for (int j =0 ; j<jmax; j++) {
+	    ret = JavaJavaC(np, scale);
+	}
+	} while (Timer() < tEnd);
+   }
+
+   public static int javafunc (int scale) {
+	int jmax = 200*scale;
+	int imax = 40;
+	int np = 0;
+	// System.out.println("Entering javafunc, scale = " + scale);
+	double tEnd = Timer() + testtime;
+	do { np = 0;
+	for (int j =0 ; j<jmax; j++) {
+	    for (int i =0 ; i<imax; i++) {
+		np = (i%2==0)?np:(np + 1);
+	    }
+	}
+	} while (Timer() < tEnd);
+	return np;
+   }
+}