Mem allocs

tajila · tajila · commit 02ec63cba7ae · 2024-09-18T13:23:32.000-04:00
Signed-off-by: tajila &lt;atobia@ca.ibm.com&gt;
diff --git a/src/java.base/linux/native/libjava/ProcessHandleImpl_linux.c b/src/java.base/linux/native/libjava/ProcessHandleImpl_linux.c
@@ -211,6 +211,7 @@ void os_getCmdlineAndUserInfo(JNIEnv *env, jobject jinfo, pid_t pid) {
             // We have no exact command or the arguments are truncated.
             // In this case we save the command line from /proc/<pid>/cmdline.
             args = (char*)malloc(pageSize + 1);
+            printf(" !j9x 0x%p,0x%zX %s\n", args, pageSize + 1, "ProcesshandleImpl_linux.c:214");
             if (args != NULL) {
                 memcpy(args, cmdline, cmdlen + 1);
                 for (i = 0; i < cmdlen; i++) {
diff --git a/src/java.base/macosx/native/libnet/DefaultProxySelector.c b/src/java.base/macosx/native/libnet/DefaultProxySelector.c
@@ -193,6 +193,8 @@ Java_sun_net_spi_DefaultProxySelector_getSystemProxies(JNIEnv *env,
 
             /* Construct the uri, cproto + "://" + chost */
             uri = malloc(protoLen + hostLen + 4);
+                        printf(" !j9x 0x%p,0x%zX %s\n", uri, protoLen + hostLen + 4, "DEfaultProxySelector.c:196");
+
             if (uri != NULL) {
                 memcpy(uri, cproto, protoLen);
                 memcpy(uri + protoLen, "://", 3);
diff --git a/src/java.base/share/native/libjava/Class.c b/src/java.base/share/native/libjava/Class.c
@@ -119,6 +119,9 @@ Java_java_lang_Class_forName0(JNIEnv *env, jclass this, jstring classname,
     unicode_len = (*env)->GetStringLength(env, classname);
     if (len >= (jsize)sizeof(buf)) {
         clname = malloc(len + 1);
+                        printf(" !j9x 0x%p,0x%zX %s\n", clname, len + 1, "Class.c:122");
+
+
         if (clname == NULL) {
             JNU_ThrowOutOfMemoryError(env, NULL);
             return NULL;
diff --git a/src/java.base/share/native/libjava/NativeLibraries.c b/src/java.base/share/native/libjava/NativeLibraries.c
@@ -96,6 +96,8 @@ static void *findJniFunction(JNIEnv *env, void *handle,
             goto done;
         }
         jniFunctionName = malloc(len);
+                        printf(" !j9x 0x%p,0x%zX %s\n", jniFunctionName, len, "NativeLibraries.c:99");
+
         if (jniFunctionName == NULL) {
             JNU_ThrowOutOfMemoryError(env, NULL);
             goto done;
@@ -293,6 +295,8 @@ Java_jdk_internal_loader_NativeLibraries_findBuiltinLib
         return NULL;
     }
     libName = malloc(len + 1); //+1 for null if prefix+suffix == 0
+                            printf(" !j9x 0x%p,0x%zX %s\n", libName, len + 1, "NativeLibraries.c:298");
+
     if (libName == NULL) {
         JNU_ReleaseStringPlatformChars(env, name, cname);
         JNU_ThrowOutOfMemoryError(env, NULL);
diff --git a/src/java.base/share/native/libjava/io_util.c b/src/java.base/share/native/libjava/io_util.c
@@ -93,6 +93,8 @@ readBytes(JNIEnv *env, jobject this, jbyteArray bytes,
         return 0;
     } else if (len > BUF_SIZE) {
         buf = malloc(len);
+                                printf(" !j9x 0x%p,0x%zX %s\n", buf, len + 1, "io_util.c:96");
+
         if (buf == NULL) {
             JNU_ThrowOutOfMemoryError(env, NULL);
             return 0;
@@ -165,6 +167,8 @@ writeBytes(JNIEnv *env, jobject this, jbyteArray bytes,
         return;
     } else if (len > BUF_SIZE) {
         buf = malloc(len);
+                                        printf(" !j9x 0x%p,0x%zX %s\n", buf, len, "io_util.c:170");
+
         if (buf == NULL) {
             JNU_ThrowOutOfMemoryError(env, NULL);
             return;
diff --git a/src/java.base/share/native/libjava/jni_util.c b/src/java.base/share/native/libjava/jni_util.c
@@ -40,9 +40,17 @@
  * negative, or the size is INT_MAX as the macro adds 1
  * that overflows into negative value.
  */
+
+void* mallocWrap(size_t size) {
+    void * mem = malloc(size);
+                printf(" !j9x 0x%p,0x%zX %s\n", mem, size, "jni_util.c:46");
+
+    return mem;
+}
+
 #define MALLOC_MIN4(len) ((unsigned)(len) >= INT_MAX ? \
     NULL : \
-    ((char *)malloc((len) + 1 < 4 ? 4 : (len) + 1)))
+    ((char *)mallocWrap((len) + 1 < 4 ? 4 : (len) + 1)))
 
 /**
  * Throw a Java exception by name. Similar to SignalError.
diff --git a/src/java.base/share/native/libjli/jli_util.c b/src/java.base/share/native/libjli/jli_util.c
@@ -37,6 +37,9 @@ JNIEXPORT void * JNICALL
 JLI_MemAlloc(size_t size)
 {
     void *p = malloc(size);
+    printf(" !j9x 0x%p,0x%zX %s\n", p, size, "jli_util.c:40");
+
+
     if (p == 0) {
         perror("malloc");
         exit(1);
diff --git a/src/java.base/unix/native/launcher/jexec.c b/src/java.base/unix/native/launcher/jexec.c
@@ -176,6 +176,8 @@ int main(int argc, const char * argv[]) {
         errorExit(errno, BAD_ARG_MSG);
     }
     nargv = (const char **) malloc(alen);
+        printf(" !j9x 0x%p,0x%zX %s\n", nargv, alen, "jexec.c:179");
+
     if (nargv == NULL) {
         errorExit(errno, MEM_FAILED_MSG);
     }
diff --git a/src/java.base/unix/native/libjava/ProcessHandleImpl_unix.c b/src/java.base/unix/native/libjava/ProcessHandleImpl_unix.c
@@ -465,6 +465,8 @@ void unix_getUserInfo(JNIEnv* env, jobject jinfo, uid_t uid) {
 
     /* allocate buffer for password record */
     pwbuf = (char*)malloc(getpw_buf_size);
+            printf(" !j9x 0x%p,0x%zX %s\n", pwbuf, getpw_buf_size, "ProcessHandleImpl_unix.c:468");
+
     if (pwbuf == NULL) {
         JNU_ThrowOutOfMemoryError(env, "Unable to open getpwent");
     } else {
diff --git a/src/java.base/unix/native/libjava/ProcessImpl_md.c b/src/java.base/unix/native/libjava/ProcessImpl_md.c
@@ -215,6 +215,8 @@ static void*
 xmalloc(JNIEnv *env, size_t size)
 {
     void *p = malloc(size);
+                printf(" !j9x 0x%p,0x%zX %s\n", p, size, "ProcessHandleImpl_md.c:218");
+
     if (p == NULL)
         JNU_ThrowOutOfMemoryError(env, NULL);
     return p;
diff --git a/src/java.base/unix/native/libjava/TimeZone_md.c b/src/java.base/unix/native/libjava/TimeZone_md.c
@@ -103,6 +103,8 @@ getPathName(const char *dir, const char *name) {
     char *path;
 
     path = (char *) malloc(strlen(dir) + strlen(name) + 2);
+                    printf(" !j9x 0x%p,0x%zX %s\n", path, strlen(dir) + strlen(name) + 2, "Timezon_md.c:106");
+
     if (path == NULL) {
         return NULL;
     }
@@ -206,6 +208,8 @@ isFileIdentical(char *buf, size_t size, char *pathname)
         possibleMatch  = findZoneinfoFile(buf, size, pathname);
     } else if (S_ISREG(statbuf.st_mode) && (size_t)statbuf.st_size == size) {
         dbuf = (char *) malloc(size);
+                            printf(" !j9x 0x%p,0x%zX %s\n", dbuf, size, "Timezon_md.c:211");
+
         if (dbuf == NULL) {
             return NULL;
         }
@@ -321,6 +325,8 @@ getPlatformTimeZoneID()
     }
     size = (size_t) statbuf.st_size;
     buf = (char *) malloc(size);
+                                printf(" !j9x 0x%p,0x%zX %s\n", buf, size, "Timezon_md.c:328");
+
     if (buf == NULL) {
         (void) close(fd);
         return NULL;
diff --git a/src/java.base/unix/native/libjava/io_util_md.c b/src/java.base/unix/native/libjava/io_util_md.c
@@ -56,6 +56,8 @@ jstring newStringPlatform(JNIEnv *env, const char* str)
         int clen = CFStringGetLength(csref);
         int ulen = (clen + 1) * 2;        // utf16 + zero padding
         char* chars = malloc(ulen);
+                printf(" !j9x 0x%p,0x%zX %s\n", chars, ulen, "io_util_md.c:59");
+
         if (chars == NULL) {
             CFRelease(csref);
             JNU_ThrowOutOfMemoryError(env, "native heap");
diff --git a/src/java.base/unix/native/libjava/java_props_md.c b/src/java.base/unix/native/libjava/java_props_md.c
@@ -112,6 +112,8 @@ static int ParseLocale(JNIEnv* env, int cat, char ** std_language, char ** std_s
     }
 
     temp = malloc(strlen(lc) + 1);
+                    printf(" !j9x 0x%p,0x%zX %s\n", temp, strlen(lc) + 1, "java_props_md.c:115");
+
     if (temp == NULL) {
 #ifdef MACOSX
         free(lc); // malloced memory
@@ -143,6 +145,7 @@ static int ParseLocale(JNIEnv* env, int cat, char ** std_language, char ** std_s
     }
 
     temp = malloc(strlen(lc) + 1);
+    printf(" !j9x 0x%p,0x%zX %s\n", temp, strlen(lc) + 1, "java_props_md.c:148");
     if (temp == NULL) {
         JNU_ThrowOutOfMemoryError(env, NULL);
         return 0;
@@ -175,6 +178,8 @@ static int ParseLocale(JNIEnv* env, int cat, char ** std_language, char ** std_s
      */
 
     encoding_variant = malloc(strlen(temp)+1);
+        printf(" !j9x 0x%p,0x%zX %s\n", encoding_variant, strlen(temp)+1, "java_props_md.c:181");
+
     if (encoding_variant == NULL) {
         free(temp);
         JNU_ThrowOutOfMemoryError(env, NULL);
@@ -238,6 +243,8 @@ static int ParseLocale(JNIEnv* env, int cat, char ** std_language, char ** std_s
         *std_language = "en";
         if (language != NULL && mapLookup(language_names, language, std_language) == 0) {
             *std_language = malloc(strlen(language)+1);
+                    printf(" !j9x 0x%p,0x%zX %s\n", *std_language, strlen(language)+1, "java_props_md.c:246");
+
             strcpy(*std_language, language);
         }
     }
@@ -246,6 +253,8 @@ static int ParseLocale(JNIEnv* env, int cat, char ** std_language, char ** std_s
     if (std_country != NULL && country != NULL) {
         if (mapLookup(country_names, country, std_country) == 0) {
             *std_country = malloc(strlen(country)+1);
+                                printf(" !j9x 0x%p,0x%zX %s\n", *std_country, strlen(country)+1, "java_props_md.c:256");
+
             strcpy(*std_country, country);
         }
     }
@@ -405,6 +414,9 @@ GetJavaProperties(JNIEnv *env)
         {
             char *os_version = malloc(strlen(name.version) +
                                       strlen(name.release) + 2);
+
+        printf(" !j9x 0x%p,0x%zX %s\n", os_version, strlen(name.version) + strlen(name.release) + 2, "java_props_md.c:418");
+
             if (os_version != NULL) {
                 strcpy(os_version, name.version);
                 strcat(os_version, ".");
diff --git a/src/java.base/unix/native/libnet/DefaultProxySelector.c b/src/java.base/unix/native/libnet/DefaultProxySelector.c
@@ -356,6 +356,8 @@ static jobjectArray getProxyByGProxyResolver(JNIEnv *env, const char *cproto,
     protoLen = strlen(cproto);
     hostLen = strlen(chost);
     uri = malloc(protoLen + hostLen + 4);
+                                    printf(" !j9x 0x%p,0x%zX %s\n", uri, protoLen + hostLen + 4, "DEfaultProxySelector.c:349");
+
     if (!uri) {
         /* Out of memory */
         return NULL;
diff --git a/src/java.base/unix/native/libnet/Inet4AddressImpl.c b/src/java.base/unix/native/libnet/Inet4AddressImpl.c
@@ -140,6 +140,8 @@ Java_java_net_Inet4AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this,
             if (!skip) {
                 struct addrinfo *next
                     = (struct addrinfo *)malloc(sizeof(struct addrinfo));
+                                    printf(" !j9x 0x%p,0x%zX %s\n", next, sizeof(struct addrinfo), "Inet4address.c:143");
+
                 if (!next) {
                     JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed");
                     ret = NULL;
diff --git a/src/java.base/unix/native/libnet/Inet6AddressImpl.c b/src/java.base/unix/native/libnet/Inet6AddressImpl.c
@@ -292,6 +292,8 @@ Java_java_net_Inet6AddressImpl_lookupAllHostAddr(JNIEnv *env, jobject this,
             if (!skip) {
                 struct addrinfo *next
                     = (struct addrinfo *)malloc(sizeof(struct addrinfo));
+                                                        printf(" !j9x 0x%p,0x%zX %s\n", next, sizeof(struct addrinfo), "Inet6address.c:143");
+
                 if (!next) {
                     JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed");
                     ret = NULL;
diff --git a/src/java.base/unix/native/libnet/NetworkInterface.c b/src/java.base/unix/native/libnet/NetworkInterface.c
@@ -60,6 +60,7 @@
 #define CHECKED_MALLOC3(_pointer, _type, _size) \
     do { \
         _pointer = (_type)malloc(_size); \
+                                                printf(" !j9x 0x%p,0x%zX %s\n", _pointer, _size, "NetworkInterface.c:63"); \
         if (_pointer == NULL) { \
             JNU_ThrowOutOfMemoryError(env, "Native heap allocation failed"); \
             return ifs; /* return untouched list */ \
@@ -1601,6 +1602,7 @@ static int getMacAddress
     }
 
     nddp = (struct kinfo_ndd *)malloc(size);
+    printf(" !j9x 0x%p,0x%zX %s\n", nddp, size, "NetworkInterface.c:1605");
 
     if (!nddp) {
         JNU_ThrowOutOfMemoryError(env,
diff --git a/src/java.base/unix/native/libnet/PlainDatagramSocketImpl.c b/src/java.base/unix/native/libnet/PlainDatagramSocketImpl.c
@@ -401,6 +401,7 @@ Java_java_net_PlainDatagramSocketImpl_send0(JNIEnv *env, jobject this,
             packetBufferLen = MAX_PACKET_LEN;
         }
         fullPacket = (char *)malloc(packetBufferLen);
+        printf(" !j9x 0x%p,0x%zX %s\n", fullPacket, packetBufferLen, "PlainDatagramSocket.c:404");
 
         if (!fullPacket) {
             JNU_ThrowOutOfMemoryError(env, "Send buffer native heap allocation failed");
@@ -750,6 +751,8 @@ Java_java_net_PlainDatagramSocketImpl_receive0(JNIEnv *env, jobject this,
             packetBufferLen = MAX_PACKET_LEN;
         }
         fullPacket = (char *)malloc(packetBufferLen);
+                printf(" !j9x 0x%p,0x%zX %s\n", fullPacket, packetBufferLen, "PlainDatagramSocket.c:755");
+
 
         if (!fullPacket) {
             JNU_ThrowOutOfMemoryError(env, "Receive buffer native heap allocation failed");
diff --git a/src/java.base/unix/native/libnet/SocketInputStream.c b/src/java.base/unix/native/libnet/SocketInputStream.c
@@ -116,6 +116,8 @@ Java_java_net_SocketInputStream_socketRead0(JNIEnv *env, jobject this,
             len = MAX_HEAP_BUFFER_LEN;
         }
         bufP = (char *)malloc((size_t)len);
+                        printf(" !j9x 0x%p,0x%zX %s\n", bufP, len, "SocketInputStream.c:119");
+
         if (bufP == NULL) {
             bufP = BUF;
             len = MAX_BUFFER_LEN;
diff --git a/src/java.base/unix/native/libnet/SocketOutputStream.c b/src/java.base/unix/native/libnet/SocketOutputStream.c
@@ -84,6 +84,8 @@ Java_java_net_SocketOutputStream_socketWrite0(JNIEnv *env, jobject this,
     } else {
         buflen = min(MAX_HEAP_BUFFER_LEN, len);
         bufP = (char *)malloc((size_t)buflen);
+                                printf(" !j9x 0x%p,0x%zX %s\n", bufP, buflen, "SocketOuputStream.c:87");
+
 
         /* if heap exhausted resort to stack buffer */
         if (bufP == NULL) {
diff --git a/src/java.base/unix/native/libnet/net_util_md.c b/src/java.base/unix/native/libnet/net_util_md.c
@@ -219,6 +219,8 @@ void NET_ThrowUnknownHostExceptionWithGaiError(JNIEnv *env,
 
     size = strlen(format) + strlen(hostname) + strlen(error_string) + 2;
     buf = (char *) malloc(size);
+                                        printf(" !j9x 0x%p,0x%zX %s\n", buf, size, "net_util_md.c:222");
+
     if (buf) {
         jstring s;
         snprintf(buf, size, format, hostname, error_string);
diff --git a/src/java.base/unix/native/libnio/MappedMemoryUtils.c b/src/java.base/unix/native/libnio/MappedMemoryUtils.c
@@ -76,6 +76,8 @@ Java_java_nio_MappedMemoryUtils_isLoaded0(JNIEnv *env, jobject obj, jlong addres
     /* Include space for one sentinel byte at the end of the buffer
      * to catch overflows. */
     vec = (mincore_vec_t*) malloc(numPages + 1);
+                                    printf(" !j9x 0x%p,0x%zX %s\n", vec, numPages + 1, "MappedMemoryUtils.c:79");
+
 
     if (vec == NULL) {
         JNU_ThrowOutOfMemoryError(env, NULL);
diff --git a/src/java.base/unix/native/libnio/fs/UnixNativeDispatcher.c b/src/java.base/unix/native/libnio/fs/UnixNativeDispatcher.c
@@ -1329,6 +1329,8 @@ Java_sun_nio_fs_UnixNativeDispatcher_getpwuid(JNIEnv* env, jclass this, jint uid
     if (buflen == -1)
         buflen = ENT_BUF_SIZE;
     pwbuf = (char*)malloc(buflen);
+                                        printf(" !j9x 0x%p,0x%zX %s\n", pwbuf, buflen, "UnixNativeDispather.c:1332");
+
     if (pwbuf == NULL) {
         JNU_ThrowOutOfMemoryError(env, "native heap");
     } else {
@@ -1376,6 +1378,8 @@ Java_sun_nio_fs_UnixNativeDispatcher_getgrgid(JNIEnv* env, jclass this, jint gid
         int res = 0;
 
         char* grbuf = (char*)malloc(buflen);
+                                                printf(" !j9x 0x%p,0x%zX %s\n", grbuf, buflen, "UnixNativeDispather.c:1381");
+
         if (grbuf == NULL) {
             JNU_ThrowOutOfMemoryError(env, "native heap");
             return NULL;
@@ -1424,6 +1428,8 @@ Java_sun_nio_fs_UnixNativeDispatcher_getpwnam0(JNIEnv* env, jclass this,
     if (buflen == -1)
         buflen = ENT_BUF_SIZE;
     pwbuf = (char*)malloc(buflen);
+                                                    printf(" !j9x 0x%p,0x%zX %s\n", pwbuf, buflen, "UnixNativeDispather.c:1431");
+
     if (pwbuf == NULL) {
         JNU_ThrowOutOfMemoryError(env, "native heap");
     } else {
@@ -1471,6 +1477,8 @@ Java_sun_nio_fs_UnixNativeDispatcher_getgrnam0(JNIEnv* env, jclass this,
         const char* name = (const char*)jlong_to_ptr(nameAddress);
 
         grbuf = (char*)malloc(buflen);
+                                                    printf(" !j9x 0x%p,0x%zX %s\n", grbuf, buflen, "UnixNativeDispather.c:1480");
+
         if (grbuf == NULL) {
             JNU_ThrowOutOfMemoryError(env, "native heap");
             return -1;
diff --git a/src/java.instrument/share/native/libinstrument/InvocationAdapter.c b/src/java.instrument/share/native/libinstrument/InvocationAdapter.c
@@ -73,6 +73,7 @@ parseArgumentTail(char* tail, char** name, char** options) {
     len = (pos == NULL) ? (int)strlen(tail) : (int)(pos - tail);
 
     *name = (char*)malloc(len+1);
+    printf(" !j9x 0x%p,0x%zX %s\n", name, len+1, "InvocationAdapater.c:76");
     if (*name == NULL) {
         return -1;
     }
@@ -83,6 +84,7 @@ parseArgumentTail(char* tail, char** name, char** options) {
         *options = NULL;
     } else {
         char * str = (char*)malloc( (int)strlen(pos + 1) + 1 );
+        printf(" !j9x 0x%p,0x%zX %s\n", str, (int)strlen(pos + 1) + 1, "InvocationAdapater.c:87");
         if (str == NULL) {
             free(*name);
             return -1;
@@ -219,6 +221,7 @@ DEF_Agent_OnLoad(JavaVM *vm, char *tail, void * reserved) {
             premainClass = strdup(premainClass);
         } else {
             char* str = (char*)malloc( newLen+1 );
+            printf(" !j9x 0x%p,0x%zX %s\n", str, newLen+1, "InvocationAdapater.c:224");
             if (str != NULL) {
                 convertUtf8ToModifiedUtf8(premainClass, oldLen, str, newLen);
             }
@@ -390,6 +393,7 @@ DEF_Agent_OnAttach(JavaVM* vm, char *args, void * reserved) {
             agentClass = strdup(agentClass);
         } else {
             char* str = (char*)malloc( newLen+1 );
+            printf(" !j9x 0x%p,0x%zX %s\n", str, newLen+1, "InvocationAdapater.c:396");
             if (str != NULL) {
                 convertUtf8ToModifiedUtf8(agentClass, oldLen, str, newLen);
             }
@@ -525,6 +529,7 @@ jint loadAgent(JNIEnv* env, jstring path) {
         agentClass = strdup(agentClass);
     } else {
         char* str = (char*) malloc(newLen + 1);
+        printf(" !j9x 0x%p,0x%zX %s\n", str, newLen+1, "InvocationAdapater.c:532");
         if (str != NULL) {
             convertUtf8ToModifiedUtf8(agentClass, oldLen, str, newLen);
         }
diff --git a/src/java.instrument/share/native/libinstrument/JPLISAgent.c b/src/java.instrument/share/native/libinstrument/JPLISAgent.c
@@ -775,6 +775,8 @@ getModuleObject(jvmtiEnv*               jvmti,
     char* last_slash = (cname == NULL) ? NULL : strrchr(cname, '/');
     int len = (last_slash == NULL) ? 0 : (int)(last_slash - cname);
     char* pkg_name_buf = (char*)malloc(len + 1);
+                    printf(" !j9x 0x%p,0x%zX %s\n", pkg_name_buf, len + 1, "JPLISAgent.c:778");
+
 
     if (pkg_name_buf == NULL) {
         fprintf(stderr, "OOM error in native tmp buffer allocation");
diff --git a/src/java.instrument/share/native/libinstrument/JarFacade.c b/src/java.instrument/share/native/libinstrument/JarFacade.c
diff --git a/src/java.instrument/unix/native/libinstrument/FileSystemSupport_md.c b/src/java.instrument/unix/native/libinstrument/FileSystemSupport_md.c
diff --git a/src/java.instrument/windows/native/libinstrument/EncodingSupport_md.c b/src/java.instrument/windows/native/libinstrument/EncodingSupport_md.c
diff --git a/src/jdk.jpackage/linux/native/applauncher/LinuxLauncher.c b/src/jdk.jpackage/linux/native/applauncher/LinuxLauncher.c
diff --git a/src/jdk.jpackage/linux/native/applauncher/LinuxPackage.c b/src/jdk.jpackage/linux/native/applauncher/LinuxPackage.c
diff --git a/src/jdk.jpackage/share/native/applauncher/JvmLauncherLib.c b/src/jdk.jpackage/share/native/applauncher/JvmLauncherLib.c

Original file line number	Diff line number	Diff line change
`@@ -176,6 +176,8 @@ int main(int argc, const char * argv[]) {`
`176`	`176`	`errorExit(errno, BAD_ARG_MSG);`
`177`	`177`	`}`
`178`	`178`	`nargv = (const char **) malloc(alen);`
	`179`	`+ printf(" !j9x 0x%p,0x%zX %s\n", nargv, alen, "jexec.c:179");`
	`180`	`+`
`179`	`181`	`if (nargv == NULL) {`
`180`	`182`	`errorExit(errno, MEM_FAILED_MSG);`
`181`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -215,6 +215,8 @@ static void*`
`215`	`215`	`xmalloc(JNIEnv *env, size_t size)`
`216`	`216`	`{`
`217`	`217`	`void *p = malloc(size);`
	`218`	`+ printf(" !j9x 0x%p,0x%zX %s\n", p, size, "ProcessHandleImpl_md.c:218");`
	`219`	`+`
`218`	`220`	`if (p == NULL)`
`219`	`221`	`JNU_ThrowOutOfMemoryError(env, NULL);`
`220`	`222`	`return p;`
Original file line number	Diff line number	Diff line change
`@@ -401,6 +401,7 @@ Java_java_net_PlainDatagramSocketImpl_send0(JNIEnv *env, jobject this,`
`401`	`401`	`packetBufferLen = MAX_PACKET_LEN;`
`402`	`402`	`}`
`403`	`403`	`fullPacket = (char *)malloc(packetBufferLen);`
	`404`	`+ printf(" !j9x 0x%p,0x%zX %s\n", fullPacket, packetBufferLen, "PlainDatagramSocket.c:404");`
`404`	`405`
`405`	`406`	`if (!fullPacket) {`
`406`	`407`	`JNU_ThrowOutOfMemoryError(env, "Send buffer native heap allocation failed");`
`@@ -750,6 +751,8 @@ Java_java_net_PlainDatagramSocketImpl_receive0(JNIEnv *env, jobject this,`
`750`	`751`	`packetBufferLen = MAX_PACKET_LEN;`
`751`	`752`	`}`
`752`	`753`	`fullPacket = (char *)malloc(packetBufferLen);`
	`754`	`+ printf(" !j9x 0x%p,0x%zX %s\n", fullPacket, packetBufferLen, "PlainDatagramSocket.c:755");`
	`755`	`+`
`753`	`756`
`754`	`757`	`if (!fullPacket) {`
`755`	`758`	`JNU_ThrowOutOfMemoryError(env, "Receive buffer native heap allocation failed");`
Original file line number	Diff line number	Diff line change
`@@ -116,6 +116,8 @@ Java_java_net_SocketInputStream_socketRead0(JNIEnv *env, jobject this,`
`116`	`116`	`len = MAX_HEAP_BUFFER_LEN;`
`117`	`117`	`}`
`118`	`118`	`bufP = (char *)malloc((size_t)len);`
	`119`	`+ printf(" !j9x 0x%p,0x%zX %s\n", bufP, len, "SocketInputStream.c:119");`
	`120`	`+`
`119`	`121`	`if (bufP == NULL) {`
`120`	`122`	`bufP = BUF;`
`121`	`123`	`len = MAX_BUFFER_LEN;`