/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c

Bug Summary

File:	jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c
Warning:	line 187, column 9 Access to field 'mJVMTIEnv' results in a dereference of a null pointer (loaded from variable 'environment')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name JPLISAgent.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -I /home/daniel/Projects/java/jdk/src/java.instrument/unix/native/libinstrument -I /home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.instrument -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjli -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjli -D JPLIS_LOGGING -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wno-unused -Wno-unused-function -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c
1/*
* Copyright (c) 2003, 2021, 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.  Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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.
*/

26/*
* Copyright 2003 Wily Technology, Inc.
*/

30#include    <jni.h>
31#include    <jvm.h>
32#include    <jvmti.h>
33#include    <stdlib.h>
34#include    <string.h>
35#include    "JPLISAgent.h"
36#include    "JPLISAssert.h"
37#include    "Utilities.h"
38#include    "Reentrancy.h"
39#include    "JavaExceptions.h"

41#include    "EncodingSupport.h"
42#include    "FileSystemSupport.h"    /* For MAXPATHLEN & uintptr_t */

44#include    "sun_instrument_InstrumentationImpl.h"

46/*
*  The JPLISAgent manages the initialization all of the Java programming language Agents.
*  It also supports the native method bridge between the JPLIS and the JVMTI.
*  It maintains a single JVMTI Env that all JPL agents share.
*  It parses command line requests and creates individual Java agents.
*/


54/*
*  private prototypes
*/

58/* Allocates an unformatted JPLIS agent data structure. Returns NULL if allocation fails. */
59JPLISAgent *
60allocateJPLISAgent(jvmtiEnv *       jvmtiEnv);

62/* Initializes an already-allocated JPLIS agent data structure. */
63JPLISInitializationError
64initializeJPLISAgent(   JPLISAgent *    agent,
                      JavaVM *        vm,
                      jvmtiEnv *      jvmtienv);
67/* De-allocates a JPLIS agent data structure. Only used in partial-failure cases at startup;
* in normal usage the JPLIS agent lives forever
*/
70void
71deallocateJPLISAgent(   jvmtiEnv *      jvmtienv,
                      JPLISAgent *    agent);

74/* Does one-time work to interrogate the JVM about capabilities and cache the answers. */
75void
76checkCapabilities(JPLISAgent * agent);

78/* Takes the elements of the command string (agent class name and options string) and
* create java strings for them.
* Returns true if a classname was found. Makes no promises beyond the textual; says nothing about whether
* the class exists or can be loaded.
* If return value is true, sets outputClassname to a non-NULL local JNI reference.
* If return value is true, sets outputOptionsString either to NULL or to a non-NULL local JNI reference.
* If return value is false, neither output parameter is set.
*/
86jboolean
87commandStringIntoJavaStrings(  JNIEnv *        jnienv,
                             const char *    classname,
                             const char *    optionsString,
                             jstring *       outputClassname,
                             jstring *       outputOptionsString);

93/* Start one Java agent from the supplied parameters.
* Most of the logic lives in a helper function that lives over in Java code--
* we pass parameters out to Java and use our own Java helper to actually
* load the agent and call the premain.
* Returns true if the Java agent class is loaded and the premain/agentmain method completes
* with no exceptions, false otherwise.
*/
100jboolean
101invokeJavaAgentMainMethod( JNIEnv *    jnienv,
                         jobject     instrumentationImpl,
                         jmethodID   agentMainMethod,
                         jstring     className,
                         jstring     optionsString);

107/* Once we have loaded the Java agent and called the premain,
* we can release the copies we have been keeping of the command line
* data (agent class name and option strings).
*/
111void
112deallocateCommandLineData(JPLISAgent * agent);

114/*
*  Common support for various class list fetchers.
*/
117typedef jvmtiError (*ClassListFetcher)
  (   jvmtiEnv *  jvmtiEnv,
      jobject     classLoader,
      jint *      classCount,
      jclass **   classes);

123/* Fetcher that ignores the class loader parameter, and uses the JVMTI to get a list of all classes.
* Returns a jvmtiError according to the underlying JVMTI service.
*/
126jvmtiError
127getAllLoadedClassesClassListFetcher(    jvmtiEnv *  jvmtiEnv,
                                      jobject     classLoader,
                                      jint *      classCount,
                                      jclass **   classes);

132/* Fetcher that uses the class loader parameter, and uses the JVMTI to get a list of all classes
* for which the supplied loader is the initiating loader.
* Returns a jvmtiError according to the underlying JVMTI service.
*/
136jvmtiError
137getInitiatedClassesClassListFetcher(    jvmtiEnv *  jvmtiEnv,
                                      jobject     classLoader,
                                      jint *      classCount,
                                      jclass **   classes);

142/*
* Common guts for two native methods, which are the same except for the policy for fetching
* the list of classes.
* Either returns a local JNI reference to an array of references to java.lang.Class.
* Can throw, if it does will alter the JNIEnv with an outstanding exception.
*/
148jobjectArray
149commonGetClassList( JNIEnv *            jnienv,
                  JPLISAgent *        agent,
                  jobject             classLoader,
                  ClassListFetcher    fetcher);


155/*
*  Misc. utilities.
*/

159/* Checked exception mapper used by the redefine classes implementation.
* Allows ClassNotFoundException or UnmodifiableClassException; maps others
* to InternalError. Can return NULL in an error case.
*/
163jthrowable
164redefineClassMapper(    JNIEnv *    jnienv,
                      jthrowable  throwableToMap);

167/* Turns a buffer of jclass * into a Java array whose elements are java.lang.Class.
* Can throw, if it does will alter the JNIEnv with an outstanding exception.
*/
170jobjectArray
171getObjectArrayFromClasses(JNIEnv* jnienv, jclass* classes, jint classCount);


174JPLISEnvironment *
175getJPLISEnvironment(jvmtiEnv * jvmtienv) {
  JPLISEnvironment * environment  = NULL((void*)0);
  jvmtiError         jvmtierror   = JVMTI_ERROR_NONE;

  jvmtierror = (*jvmtienv)->GetEnvironmentLocalStorage(
1
Value assigned to 'environment'→
                                          jvmtienv,
                                          (void**)&environment);
  /* can be called from any phase */
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 183);
2
←
Assuming 'jvmtierror' is equal to JVMTI_ERROR_NONE→

  if (jvmtierror2.1
'jvmtierror' is equal to JVMTI_ERROR_NONE
 == JVMTI_ERROR_NONE) {
3
←
Taking true branch→
      jplis_assert(environment != NULL)JPLISAssertCondition((jboolean)(environment != ((void*)0)), "environment != NULL"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 186);
4
←
Assuming 'environment' is equal to null→
      jplis_assert(environment->mJVMTIEnv == jvmtienv)JPLISAssertCondition((jboolean)(environment->mJVMTIEnv == jvmtienv
), "environment->mJVMTIEnv == jvmtienv", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 187);
5
←
Access to field 'mJVMTIEnv' results in a dereference of a null pointer (loaded from variable 'environment')
  } else {
      environment = NULL((void*)0);
  }
  return environment;
192}

194/*
*  OnLoad processing code.
*/

198/*
*  Creates a new JPLISAgent.
*  Returns error if the agent cannot be created and initialized.
*  The JPLISAgent* pointed to by agent_ptr is set to the new broker,
*  or NULL if an error has occurred.
*/
204JPLISInitializationError
205createNewJPLISAgent(JavaVM * vm, JPLISAgent **agent_ptr) {
  JPLISInitializationError initerror       = JPLIS_INIT_ERROR_NONE;
  jvmtiEnv *               jvmtienv        = NULL((void*)0);
  jint                     jnierror        = JNI_OK0;

  *agent_ptr = NULL((void*)0);
  jnierror = (*vm)->GetEnv(  vm,
                             (void **) &jvmtienv,
                             JVMTI_VERSION_1_1);
  if ( jnierror != JNI_OK0 ) {
      initerror = JPLIS_INIT_ERROR_CANNOT_CREATE_NATIVE_AGENT;
  } else {
      JPLISAgent * agent = allocateJPLISAgent(jvmtienv);
      if ( agent == NULL((void*)0) ) {
          initerror = JPLIS_INIT_ERROR_ALLOCATION_FAILURE;
      } else {
          initerror = initializeJPLISAgent(  agent,
                                             vm,
                                             jvmtienv);
          if ( initerror == JPLIS_INIT_ERROR_NONE ) {
              *agent_ptr = agent;
          } else {
              deallocateJPLISAgent(jvmtienv, agent);
          }
      }

      /* don't leak envs */
      if ( initerror != JPLIS_INIT_ERROR_NONE ) {
          jvmtiError jvmtierror = (*jvmtienv)->DisposeEnvironment(jvmtienv);
          /* can be called from any phase */
          jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 235);
      }
  }

  return initerror;
240}

242/*
*  Allocates a JPLISAgent. Returns NULL if it cannot be allocated
*/
245JPLISAgent *
246allocateJPLISAgent(jvmtiEnv * jvmtienv) {
return (JPLISAgent *) allocate( jvmtienv,
                                  sizeof(JPLISAgent));
249}

251JPLISInitializationError
252initializeJPLISAgent(   JPLISAgent *    agent,
                      JavaVM *        vm,
                      jvmtiEnv *      jvmtienv) {
  jvmtiError      jvmtierror = JVMTI_ERROR_NONE;
  jvmtiPhase      phase;

  agent->mJVM                                      = vm;
  agent->mNormalEnvironment.mJVMTIEnv              = jvmtienv;
  agent->mNormalEnvironment.mAgent                 = agent;
  agent->mNormalEnvironment.mIsRetransformer       = JNI_FALSE0;
  agent->mRetransformEnvironment.mJVMTIEnv         = NULL((void*)0);        /* NULL until needed */
  agent->mRetransformEnvironment.mAgent            = agent;
  agent->mRetransformEnvironment.mIsRetransformer  = JNI_FALSE0;   /* JNI_FALSE until mJVMTIEnv is set */
  agent->mAgentmainCaller                          = NULL((void*)0);
  agent->mInstrumentationImpl                      = NULL((void*)0);
  agent->mPremainCaller                            = NULL((void*)0);
  agent->mTransform                                = NULL((void*)0);
  agent->mRedefineAvailable                        = JNI_FALSE0;   /* assume no for now */
  agent->mRedefineAdded                            = JNI_FALSE0;
  agent->mNativeMethodPrefixAvailable              = JNI_FALSE0;   /* assume no for now */
  agent->mNativeMethodPrefixAdded                  = JNI_FALSE0;
  agent->mAgentClassName                           = NULL((void*)0);
  agent->mOptionsString                            = NULL((void*)0);
  agent->mJarfile                                  = NULL((void*)0);

  /* make sure we can recover either handle in either direction.
   * the agent has a ref to the jvmti; make it mutual
   */
  jvmtierror = (*jvmtienv)->SetEnvironmentLocalStorage(
                                          jvmtienv,
                                          &(agent->mNormalEnvironment));
  /* can be called from any phase */
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 284);

  /* check what capabilities are available */
  checkCapabilities(agent);

  /* check phase - if live phase then we don't need the VMInit event */
  jvmtierror = (*jvmtienv)->GetPhase(jvmtienv, &phase);
  /* can be called from any phase */
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 292);
  if (phase == JVMTI_PHASE_LIVE) {
      return JPLIS_INIT_ERROR_NONE;
  }

  if (phase != JVMTI_PHASE_ONLOAD) {
      /* called too early or called too late; either way bail out */
      return JPLIS_INIT_ERROR_FAILURE;
  }

  /* now turn on the VMInit event */
  if ( jvmtierror == JVMTI_ERROR_NONE ) {
      jvmtiEventCallbacks callbacks;
      memset(&callbacks, 0, sizeof(callbacks));
      callbacks.VMInit = &eventHandlerVMInit;

      jvmtierror = (*jvmtienv)->SetEventCallbacks( jvmtienv,
                                                   &callbacks,
                                                   sizeof(callbacks));
      check_phase_ret_blob(jvmtierror, JPLIS_INIT_ERROR_FAILURE)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return (JPLIS_INIT_ERROR_FAILURE
); };
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 312);
  }

  if ( jvmtierror == JVMTI_ERROR_NONE ) {
      jvmtierror = (*jvmtienv)->SetEventNotificationMode(
                                              jvmtienv,
                                              JVMTI_ENABLE,
                                              JVMTI_EVENT_VM_INIT,
                                              NULL((void*)0) /* all threads */);
      check_phase_ret_blob(jvmtierror, JPLIS_INIT_ERROR_FAILURE)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return (JPLIS_INIT_ERROR_FAILURE
); };
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 322);
  }

  return (jvmtierror == JVMTI_ERROR_NONE)? JPLIS_INIT_ERROR_NONE : JPLIS_INIT_ERROR_FAILURE;
326}

328void
329deallocateJPLISAgent(jvmtiEnv * jvmtienv, JPLISAgent * agent) {
  deallocate(jvmtienv, agent);
331}


334JPLISInitializationError
335recordCommandLineData(  JPLISAgent *    agent,
                      const char *    agentClassName,
                      const char *    optionsString ) {
  JPLISInitializationError    initerror   = JPLIS_INIT_ERROR_NONE;
  char *      ourCopyOfAgentClassName     = NULL((void*)0);
  char *      ourCopyOfOptionsString      = NULL((void*)0);

  /* if no actual params, bail out now */
  if ((agentClassName == NULL((void*)0)) || (*agentClassName == 0)) {
      initerror = JPLIS_INIT_ERROR_AGENT_CLASS_NOT_SPECIFIED;
  } else {
      ourCopyOfAgentClassName = allocate(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv, strlen(agentClassName)+1);
      if (ourCopyOfAgentClassName == NULL((void*)0)) {
          initerror = JPLIS_INIT_ERROR_ALLOCATION_FAILURE;
      } else {
          if (optionsString != NULL((void*)0)) {
              ourCopyOfOptionsString = allocate(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv, strlen(optionsString)+1);
              if (ourCopyOfOptionsString == NULL((void*)0)) {
                  deallocate(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv, ourCopyOfAgentClassName);
                  initerror = JPLIS_INIT_ERROR_ALLOCATION_FAILURE;
              }
          }
      }
  }

  if (initerror == JPLIS_INIT_ERROR_NONE) {
      strcpy(ourCopyOfAgentClassName, agentClassName);
      if (optionsString != NULL((void*)0)) {
          strcpy(ourCopyOfOptionsString, optionsString);
      }
      agent->mAgentClassName = ourCopyOfAgentClassName;
      agent->mOptionsString = ourCopyOfOptionsString;
  }

  return initerror;
370}

372/*
*  VMInit processing code.
*/


377/*
* If this call fails, the JVM launch will ultimately be aborted,
* so we don't have to be super-careful to clean up in partial failure
* cases.
*/
382jboolean
383processJavaStart(   JPLISAgent *    agent,
                  JNIEnv *        jnienv) {
  jboolean    result;

  /*
   *  OK, Java is up now. We can start everything that needs Java.
   */

  /*
   *  First make our fallback InternalError throwable.
   */
  result = initializeFallbackError(jnienv);
  jplis_assert_msg(result, "fallback init failed")JPLISAssertConditionWithMessage((jboolean)(result), "result",
 "fallback init failed", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 395);

  /*
   *  Now make the InstrumentationImpl instance.
   */
  if ( result ) {
      result = createInstrumentationImpl(jnienv, agent);
      jplis_assert_msg(result, "instrumentation instance creation failed")JPLISAssertConditionWithMessage((jboolean)(result), "result",
 "instrumentation instance creation failed", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 402);
  }


  /*
   *  Register a handler for ClassFileLoadHook (without enabling this event).
   *  Turn off the VMInit handler.
   */
  if ( result ) {
      result = setLivePhaseEventHandlers(agent);
      jplis_assert_msg(result, "setting of live phase VM handlers failed")JPLISAssertConditionWithMessage((jboolean)(result), "result",
 "setting of live phase VM handlers failed", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 412);
  }

  /*
   *  Load the Java agent, and call the premain.
   */
  if ( result ) {
      result = startJavaAgent(agent, jnienv,
                              agent->mAgentClassName, agent->mOptionsString,
                              agent->mPremainCaller);
      jplis_assert_msg(result, "agent load/premain call failed")JPLISAssertConditionWithMessage((jboolean)(result), "result",
 "agent load/premain call failed", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 422);
  }

  /*
   * Finally surrender all of the tracking data that we don't need any more.
   * If something is wrong, skip it, we will be aborting the JVM anyway.
   */
  if ( result ) {
      deallocateCommandLineData(agent);
  }

  return result;
434}

436jboolean
437startJavaAgent( JPLISAgent *    agent,
              JNIEnv *        jnienv,
              const char *    classname,
              const char *    optionsString,
              jmethodID       agentMainMethod) {
  jboolean    success = JNI_FALSE0;
  jstring classNameObject = NULL((void*)0);
  jstring optionsStringObject = NULL((void*)0);

  success = commandStringIntoJavaStrings(    jnienv,
                                             classname,
                                             optionsString,
                                             &classNameObject,
                                             &optionsStringObject);

  if (success) {
      success = invokeJavaAgentMainMethod(   jnienv,
                                             agent->mInstrumentationImpl,
                                             agentMainMethod,
                                             classNameObject,
                                             optionsStringObject);
  }

  return success;
461}

463void
464deallocateCommandLineData( JPLISAgent * agent) {
  deallocate(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv, (void*)agent->mAgentClassName);
  deallocate(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv, (void*)agent->mOptionsString);

  /* zero things out so it is easier to see what is going on */
  agent->mAgentClassName = NULL((void*)0);
  agent->mOptionsString = NULL((void*)0);
471}

473/*
* Create the java.lang.instrument.Instrumentation instance
* and access information for it (method IDs, etc)
*/
477jboolean
478createInstrumentationImpl( JNIEnv *        jnienv,
                         JPLISAgent *    agent) {
  jclass      implClass               = NULL((void*)0);
  jboolean    errorOutstanding        = JNI_FALSE0;
  jobject     resultImpl              = NULL((void*)0);
  jmethodID   premainCallerMethodID   = NULL((void*)0);
  jmethodID   agentmainCallerMethodID = NULL((void*)0);
  jmethodID   transformMethodID       = NULL((void*)0);
  jmethodID   constructorID           = NULL((void*)0);
  jobject     localReference          = NULL((void*)0);

  /* First find the class of our implementation */
  implClass = (*jnienv)->FindClass(   jnienv,
                                      JPLIS_INSTRUMENTIMPL_CLASSNAME"sun/instrument/InstrumentationImpl");
  errorOutstanding = checkForAndClearThrowable(jnienv);
  errorOutstanding = errorOutstanding || (implClass == NULL((void*)0));
  jplis_assert_msg(!errorOutstanding, "find class on InstrumentationImpl failed")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "find class on InstrumentationImpl failed"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 494);

  if ( !errorOutstanding ) {
      constructorID = (*jnienv)->GetMethodID( jnienv,
                                              implClass,
                                              JPLIS_INSTRUMENTIMPL_CONSTRUCTOR_METHODNAME"<init>",
                                              JPLIS_INSTRUMENTIMPL_CONSTRUCTOR_METHODSIGNATURE"(JZZ)V");
      errorOutstanding = checkForAndClearThrowable(jnienv);
      errorOutstanding = errorOutstanding || (constructorID == NULL((void*)0));
      jplis_assert_msg(!errorOutstanding, "find constructor on InstrumentationImpl failed")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "find constructor on InstrumentationImpl failed"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 503);
      }

  if ( !errorOutstanding ) {
      jlong   peerReferenceAsScalar = (jlong)(intptr_t) agent;
      localReference = (*jnienv)->NewObject(  jnienv,
                                              implClass,
                                              constructorID,
                                              peerReferenceAsScalar,
                                              agent->mRedefineAdded,
                                              agent->mNativeMethodPrefixAdded);
      errorOutstanding = checkForAndClearThrowable(jnienv);
      errorOutstanding = errorOutstanding || (localReference == NULL((void*)0));
      jplis_assert_msg(!errorOutstanding, "call constructor on InstrumentationImpl failed")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "call constructor on InstrumentationImpl failed"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 516);
  }

  if ( !errorOutstanding ) {
      resultImpl = (*jnienv)->NewGlobalRef(jnienv, localReference);
      errorOutstanding = checkForAndClearThrowable(jnienv);
      jplis_assert_msg(!errorOutstanding, "copy local ref to global ref")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "copy local ref to global ref", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 522);
  }

  /* Now look up the method ID for the pre-main caller (we will need this more than once) */
  if ( !errorOutstanding ) {
      premainCallerMethodID = (*jnienv)->GetMethodID( jnienv,
                                                      implClass,
                                                      JPLIS_INSTRUMENTIMPL_PREMAININVOKER_METHODNAME"loadClassAndCallPremain",
                                                      JPLIS_INSTRUMENTIMPL_PREMAININVOKER_METHODSIGNATURE"(Ljava/lang/String;Ljava/lang/String;)V");
      errorOutstanding = checkForAndClearThrowable(jnienv);
      errorOutstanding = errorOutstanding || (premainCallerMethodID == NULL((void*)0));
      jplis_assert_msg(!errorOutstanding, "can't find premain invoker methodID")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't find premain invoker methodID",
 "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 533);
  }

  /* Now look up the method ID for the agent-main caller */
  if ( !errorOutstanding ) {
      agentmainCallerMethodID = (*jnienv)->GetMethodID( jnienv,
                                                        implClass,
                                                        JPLIS_INSTRUMENTIMPL_AGENTMAININVOKER_METHODNAME"loadClassAndCallAgentmain",
                                                        JPLIS_INSTRUMENTIMPL_AGENTMAININVOKER_METHODSIGNATURE"(Ljava/lang/String;Ljava/lang/String;)V");
      errorOutstanding = checkForAndClearThrowable(jnienv);
      errorOutstanding = errorOutstanding || (agentmainCallerMethodID == NULL((void*)0));
      jplis_assert_msg(!errorOutstanding, "can't find agentmain invoker methodID")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't find agentmain invoker methodID"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 544);
  }

  /* Now look up the method ID for the transform method (we will need this constantly) */
  if ( !errorOutstanding ) {
      transformMethodID = (*jnienv)->GetMethodID( jnienv,
                                                  implClass,
                                                  JPLIS_INSTRUMENTIMPL_TRANSFORM_METHODNAME"transform",
                                                  JPLIS_INSTRUMENTIMPL_TRANSFORM_METHODSIGNATURE"(Ljava/lang/Module;Ljava/lang/ClassLoader;Ljava/lang/String;Ljava/lang/Class;Ljava/security/ProtectionDomain;[BZ)[B");
      errorOutstanding = checkForAndClearThrowable(jnienv);
      errorOutstanding = errorOutstanding || (transformMethodID == NULL((void*)0));
      jplis_assert_msg(!errorOutstanding, "can't find transform methodID")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't find transform methodID", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 555);
  }

  if ( !errorOutstanding ) {
      agent->mInstrumentationImpl = resultImpl;
      agent->mPremainCaller       = premainCallerMethodID;
      agent->mAgentmainCaller     = agentmainCallerMethodID;
      agent->mTransform           = transformMethodID;
  }

  return !errorOutstanding;
566}

568jboolean
569commandStringIntoJavaStrings(  JNIEnv *        jnienv,
                             const char *    classname,
                             const char *    optionsString,
                             jstring *       outputClassname,
                             jstring *       outputOptionsString) {
  jstring     classnameJavaString     = NULL((void*)0);
  jstring     optionsJavaString       = NULL((void*)0);
  jboolean    errorOutstanding        = JNI_TRUE1;

  classnameJavaString = (*jnienv)->NewStringUTF(jnienv, classname);
  errorOutstanding = checkForAndClearThrowable(jnienv);
  jplis_assert_msg(!errorOutstanding, "can't create class name java string")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't create class name java string",
 "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 580);

  if ( !errorOutstanding ) {
      if ( optionsString != NULL((void*)0)) {
          optionsJavaString = (*jnienv)->NewStringUTF(jnienv, optionsString);
          errorOutstanding = checkForAndClearThrowable(jnienv);
          jplis_assert_msg(!errorOutstanding, "can't create options java string")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't create options java string", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 586);
      }

      if ( !errorOutstanding ) {
          *outputClassname        = classnameJavaString;
          *outputOptionsString    = optionsJavaString;
      }
  }

  return !errorOutstanding;
596}


599jboolean
600invokeJavaAgentMainMethod( JNIEnv *    jnienv,
                         jobject     instrumentationImpl,
                         jmethodID   mainCallingMethod,
                         jstring     className,
                         jstring     optionsString) {
  jboolean errorOutstanding = JNI_FALSE0;

  jplis_assert(mainCallingMethod != NULL)JPLISAssertCondition((jboolean)(mainCallingMethod != ((void*)
0)), "mainCallingMethod != NULL", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 607);
  if ( mainCallingMethod != NULL((void*)0) ) {
      (*jnienv)->CallVoidMethod(  jnienv,
                                  instrumentationImpl,
                                  mainCallingMethod,
                                  className,
                                  optionsString);
      errorOutstanding = checkForThrowable(jnienv);
      if ( errorOutstanding ) {
          logThrowable(jnienv);
      }
      checkForAndClearThrowable(jnienv);
  }
  return !errorOutstanding;
621}

623jboolean
624setLivePhaseEventHandlers(  JPLISAgent * agent) {
  jvmtiEventCallbacks callbacks;
  jvmtiEnv *          jvmtienv = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jvmtiError          jvmtierror;

  /* first swap out the handlers (switch from the VMInit handler, which we do not need,
   * to the ClassFileLoadHook handler, which is what the agents need from now on)
   */
  memset(&callbacks, 0, sizeof(callbacks));
  callbacks.ClassFileLoadHook = &eventHandlerClassFileLoadHook;

  jvmtierror = (*jvmtienv)->SetEventCallbacks( jvmtienv,
                                               &callbacks,
                                               sizeof(callbacks));
  check_phase_ret_false(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return (jboolean
) 0; };
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 639);


  if ( jvmtierror == JVMTI_ERROR_NONE ) {
      /* turn off VMInit */
      jvmtierror = (*jvmtienv)->SetEventNotificationMode(
                                                  jvmtienv,
                                                  JVMTI_DISABLE,
                                                  JVMTI_EVENT_VM_INIT,
                                                  NULL((void*)0) /* all threads */);
      check_phase_ret_false(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return (jboolean
) 0; };
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 650);
  }

  return (jvmtierror == JVMTI_ERROR_NONE);
654}

656/**
*  Check if the can_redefine_classes capability is available.
*/
659void
660checkCapabilities(JPLISAgent * agent) {
  jvmtiEnv *          jvmtienv = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jvmtiCapabilities   potentialCapabilities;
  jvmtiError          jvmtierror;

  memset(&potentialCapabilities, 0, sizeof(potentialCapabilities));

  jvmtierror = (*jvmtienv)->GetPotentialCapabilities(jvmtienv, &potentialCapabilities);
  check_phase_ret(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return; };
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 669);

  if ( jvmtierror == JVMTI_ERROR_NONE ) {
      if ( potentialCapabilities.can_redefine_classes == 1 ) {
          agent->mRedefineAvailable = JNI_TRUE1;
      }
      if ( potentialCapabilities.can_set_native_method_prefix == 1 ) {
          agent->mNativeMethodPrefixAvailable = JNI_TRUE1;
      }
  }
679}

681/**
* Enable native method prefix in one JVM TI environment
*/
684void
685enableNativeMethodPrefixCapability(jvmtiEnv * jvmtienv) {
  jvmtiCapabilities   desiredCapabilities;
  jvmtiError          jvmtierror;

      jvmtierror = (*jvmtienv)->GetCapabilities(jvmtienv, &desiredCapabilities);
      /* can be called from any phase */
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 691);
      desiredCapabilities.can_set_native_method_prefix = 1;
      jvmtierror = (*jvmtienv)->AddCapabilities(jvmtienv, &desiredCapabilities);
      check_phase_ret(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return; };
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 695);
696}


699/**
* Add the can_set_native_method_prefix capability
*/
702void
703addNativeMethodPrefixCapability(JPLISAgent * agent) {
  if (agent->mNativeMethodPrefixAvailable && !agent->mNativeMethodPrefixAdded) {
      jvmtiEnv * jvmtienv = agent->mNormalEnvironment.mJVMTIEnv;
      enableNativeMethodPrefixCapability(jvmtienv);

      jvmtienv = agent->mRetransformEnvironment.mJVMTIEnv;
      if (jvmtienv != NULL((void*)0)) {
          enableNativeMethodPrefixCapability(jvmtienv);
      }
      agent->mNativeMethodPrefixAdded = JNI_TRUE1;
  }
714}

716/**
* Add the can_maintain_original_method_order capability (for testing)
*/
719void
720addOriginalMethodOrderCapability(JPLISAgent * agent) {
  jvmtiEnv *          jvmtienv = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jvmtiCapabilities   desiredCapabilities;
  jvmtiError          jvmtierror;

  jvmtierror = (*jvmtienv)->GetCapabilities(jvmtienv, &desiredCapabilities);
  /* can be called from any phase */
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 727);
  desiredCapabilities.can_maintain_original_method_order = 1;
  jvmtierror = (*jvmtienv)->AddCapabilities(jvmtienv, &desiredCapabilities);
  check_phase_ret(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return; };
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 731);
732}

734/**
* Add the can_redefine_classes capability
*/
737void
738addRedefineClassesCapability(JPLISAgent * agent) {
  jvmtiEnv *          jvmtienv = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jvmtiCapabilities   desiredCapabilities;
  jvmtiError          jvmtierror;

  if (agent->mRedefineAvailable && !agent->mRedefineAdded) {
      jvmtierror = (*jvmtienv)->GetCapabilities(jvmtienv, &desiredCapabilities);
      /* can be called from any phase */
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 746);
      desiredCapabilities.can_redefine_classes = 1;
      jvmtierror = (*jvmtienv)->AddCapabilities(jvmtienv, &desiredCapabilities);
      check_phase_ret(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return; };

      /*
       * With mixed premain/agentmain agents then it's possible that the
       * capability was potentially available in the onload phase but
       * subsequently unavailable in the live phase.
       */
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE ||JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
 || jvmtierror == JVMTI_ERROR_NOT_AVAILABLE), "jvmtierror == JVMTI_ERROR_NONE || jvmtierror == JVMTI_ERROR_NOT_AVAILABLE"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 757)
                   jvmtierror == JVMTI_ERROR_NOT_AVAILABLE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
 || jvmtierror == JVMTI_ERROR_NOT_AVAILABLE), "jvmtierror == JVMTI_ERROR_NONE || jvmtierror == JVMTI_ERROR_NOT_AVAILABLE"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 757);
      if (jvmtierror == JVMTI_ERROR_NONE) {
          agent->mRedefineAdded = JNI_TRUE1;
      }
  }
762}

764static jobject
765getModuleObject(jvmtiEnv*               jvmti,
              jobject                 loaderObject,
              const char*             cname) {
  jvmtiError err = JVMTI_ERROR_NONE;
  jobject moduleObject = NULL((void*)0);

  /* find last slash in the class name */
  char* last_slash = (cname == NULL((void*)0)) ? NULL((void*)0) : strrchr(cname, '/');
  int len = (last_slash == NULL((void*)0)) ? 0 : (int)(last_slash - cname);
  char* pkg_name_buf = (char*)malloc(len + 1);

  if (pkg_name_buf == NULL((void*)0)) {
      fprintf(stderr, "OOM error in native tmp buffer allocation")__fprintf_chk (stderr, 2 - 1, "OOM error in native tmp buffer allocation"
);
      return NULL((void*)0);
  }
  if (last_slash != NULL((void*)0)) {
      strncpy(pkg_name_buf, cname, len);
  }
  pkg_name_buf[len] = '\0';

  err = (*jvmti)->GetNamedModule(jvmti, loaderObject, pkg_name_buf, &moduleObject);
  free((void*)pkg_name_buf);
  check_phase_ret_blob(err, NULL)if ((err) == JVMTI_ERROR_WRONG_PHASE) { return (((void*)0)); };
  jplis_assert_msg(err == JVMTI_ERROR_NONE, "error in the JVMTI GetNamedModule")JPLISAssertConditionWithMessage((jboolean)(err == JVMTI_ERROR_NONE
), "err == JVMTI_ERROR_NONE", "error in the JVMTI GetNamedModule"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 788);

  return moduleObject;
791}

793/*
*  Support for the JVMTI callbacks
*/

797void
798transformClassFile(             JPLISAgent *            agent,
                              JNIEnv *                jnienv,
                              jobject                 loaderObject,
                              const char*             name,
                              jclass                  classBeingRedefined,
                              jobject                 protectionDomain,
                              jint                    class_data_len,
                              const unsigned char*    class_data,
                              jint*                   new_class_data_len,
                              unsigned char**         new_class_data,
                              jboolean                is_retransformer) {
  jboolean        errorOutstanding        = JNI_FALSE0;
  jstring         classNameStringObject   = NULL((void*)0);
  jarray          classFileBufferObject   = NULL((void*)0);
  jarray          transformedBufferObject = NULL((void*)0);
  jsize           transformedBufferSize   = 0;
  unsigned char * resultBuffer            = NULL((void*)0);
  jboolean        shouldRun               = JNI_FALSE0;

  /* only do this if we aren't already in the middle of processing a class on this thread */
  shouldRun = tryToAcquireReentrancyToken(
                              jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv,
                              NULL((void*)0));  /* this thread */

  if ( shouldRun ) {
      /* first marshall all the parameters */
      classNameStringObject = (*jnienv)->NewStringUTF(jnienv,
                                                      name);
      errorOutstanding = checkForAndClearThrowable(jnienv);
      jplis_assert_msg(!errorOutstanding, "can't create name string")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't create name string", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 827);

      if ( !errorOutstanding ) {
          classFileBufferObject = (*jnienv)->NewByteArray(jnienv,
                                                          class_data_len);
          errorOutstanding = checkForAndClearThrowable(jnienv);
          jplis_assert_msg(!errorOutstanding, "can't create byte array")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't create byte array", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 833);
      }

      if ( !errorOutstanding ) {
          jbyte * typedBuffer = (jbyte *) class_data; /* nasty cast, dumb JNI interface, const missing */
                                                      /* The sign cast is safe. The const cast is dumb. */
          (*jnienv)->SetByteArrayRegion(  jnienv,
                                          classFileBufferObject,
                                          0,
                                          class_data_len,
                                          typedBuffer);
          errorOutstanding = checkForAndClearThrowable(jnienv);
          jplis_assert_msg(!errorOutstanding, "can't set byte array region")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't set byte array region", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 845);
      }

      /*  now call the JPL agents to do the transforming */
      /*  potential future optimization: may want to skip this if there are none */
      if ( !errorOutstanding ) {
          jobject moduleObject = NULL((void*)0);

          if (classBeingRedefined == NULL((void*)0)) {
              moduleObject = getModuleObject(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv, loaderObject, name);
          } else {
              // Redefine or retransform, InstrumentationImpl.transform() will use
              // classBeingRedefined.getModule() to get the module.
          }
          jplis_assert(agent->mInstrumentationImpl != NULL)JPLISAssertCondition((jboolean)(agent->mInstrumentationImpl
 != ((void*)0)), "agent->mInstrumentationImpl != NULL", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 859);
          jplis_assert(agent->mTransform != NULL)JPLISAssertCondition((jboolean)(agent->mTransform != ((void
*)0)), "agent->mTransform != NULL", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 860);
          transformedBufferObject = (*jnienv)->CallObjectMethod(
                                              jnienv,
                                              agent->mInstrumentationImpl,
                                              agent->mTransform,
                                              moduleObject,
                                              loaderObject,
                                              classNameStringObject,
                                              classBeingRedefined,
                                              protectionDomain,
                                              classFileBufferObject,
                                              is_retransformer);
          errorOutstanding = checkForAndClearThrowable(jnienv);
          jplis_assert_msg(!errorOutstanding, "transform method call failed")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "transform method call failed", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 873);
      }

      /* Finally, unmarshall the parameters (if someone touched the buffer, tell the JVM) */
      if ( !errorOutstanding ) {
          if ( transformedBufferObject != NULL((void*)0) ) {
              transformedBufferSize = (*jnienv)->GetArrayLength(  jnienv,
                                                                  transformedBufferObject);
              errorOutstanding = checkForAndClearThrowable(jnienv);
              jplis_assert_msg(!errorOutstanding, "can't get array length")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't get array length", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 882);

              if ( !errorOutstanding ) {
                  /* allocate the response buffer with the JVMTI allocate call.
                   *  This is what the JVMTI spec says to do for Class File Load hook responses
                   */
                  jvmtiError  allocError = (*(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv))->Allocate(jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv,
                                                                           transformedBufferSize,
                                                                           &resultBuffer);
                  errorOutstanding = (allocError != JVMTI_ERROR_NONE);
                  jplis_assert_msg(!errorOutstanding, "can't allocate result buffer")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't allocate result buffer", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 892);
              }

              if ( !errorOutstanding ) {
                  (*jnienv)->GetByteArrayRegion(  jnienv,
                                                  transformedBufferObject,
                                                  0,
                                                  transformedBufferSize,
                                                  (jbyte *) resultBuffer);
                  errorOutstanding = checkForAndClearThrowable(jnienv);
                  jplis_assert_msg(!errorOutstanding, "can't get byte array region")JPLISAssertConditionWithMessage((jboolean)(!errorOutstanding)
, "!errorOutstanding", "can't get byte array region", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 902);

                  /* in this case, we will not return the buffer to the JVMTI,
                   * so we need to deallocate it ourselves
                   */
                  if ( errorOutstanding ) {
                      deallocate( jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv,
                                 (void*)resultBuffer);
                  }
              }

              if ( !errorOutstanding ) {
                  *new_class_data_len = (transformedBufferSize);
                  *new_class_data     = resultBuffer;
              }
          }
      }

      /* release the token */
      releaseReentrancyToken( jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv,
                              NULL((void*)0));      /* this thread */

  }

  return;
927}

929/*
*  Misc. internal utilities.
*/

933/*
*  The only checked exceptions we can throw are ClassNotFoundException and
*  UnmodifiableClassException. All others map to InternalError.
*/
937jthrowable
938redefineClassMapper(    JNIEnv *    jnienv,
                      jthrowable  throwableToMap) {
  jthrowable  mappedThrowable = NULL((void*)0);

  jplis_assert(isSafeForJNICalls(jnienv))JPLISAssertCondition((jboolean)(isSafeForJNICalls(jnienv)), "isSafeForJNICalls(jnienv)"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 942);
  jplis_assert(!isUnchecked(jnienv, throwableToMap))JPLISAssertCondition((jboolean)(!isUnchecked(jnienv, throwableToMap
)), "!isUnchecked(jnienv, throwableToMap)", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 943);

  if ( isInstanceofClassName( jnienv,
                              throwableToMap,
                              "java/lang/ClassNotFoundException") ) {
      mappedThrowable = throwableToMap;
  } else {
      if ( isInstanceofClassName( jnienv,
                              throwableToMap,
                              "java/lang/instrument/UnmodifiableClassException")) {
          mappedThrowable = throwableToMap;
      } else {
          jstring message = NULL((void*)0);

          message = getMessageFromThrowable(jnienv, throwableToMap);
          mappedThrowable = createInternalError(jnienv, message);
      }
  }

  jplis_assert(isSafeForJNICalls(jnienv))JPLISAssertCondition((jboolean)(isSafeForJNICalls(jnienv)), "isSafeForJNICalls(jnienv)"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 962);
  return mappedThrowable;
964}

966jobjectArray
967getObjectArrayFromClasses(JNIEnv* jnienv, jclass* classes, jint classCount) {
  jclass          classArrayClass = NULL((void*)0);
  jobjectArray    localArray      = NULL((void*)0);
  jint            classIndex      = 0;
  jboolean        errorOccurred   = JNI_FALSE0;

  /* get the class array class */
  classArrayClass = (*jnienv)->FindClass(jnienv, "java/lang/Class");
  errorOccurred = checkForThrowable(jnienv);

  if (!errorOccurred) {
      jplis_assert_msg(classArrayClass != NULL, "FindClass returned null class")JPLISAssertConditionWithMessage((jboolean)(classArrayClass !=
 ((void*)0)), "classArrayClass != NULL", "FindClass returned null class"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 978);

      /* create the array for the classes */
      localArray = (*jnienv)->NewObjectArray(jnienv, classCount, classArrayClass, NULL((void*)0));
      errorOccurred = checkForThrowable(jnienv);

      if (!errorOccurred) {
          jplis_assert_msg(localArray != NULL, "NewObjectArray returned null array")JPLISAssertConditionWithMessage((jboolean)(localArray != ((void
*)0)), "localArray != NULL", "NewObjectArray returned null array"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 985);

          /* now copy refs to all the classes and put them into the array */
          for (classIndex = 0; classIndex < classCount; classIndex++) {
              /* put class into array */
              (*jnienv)->SetObjectArrayElement(jnienv, localArray, classIndex, classes[classIndex]);
              errorOccurred = checkForThrowable(jnienv);

              if (errorOccurred) {
                  localArray = NULL((void*)0);
                  break;
              }
          }
      }
  }

  return localArray;
1002}


1005/* Return the environment with the retransformation capability.
* Create it if it doesn't exist.
* Return NULL if it can't be created.
*/
1009jvmtiEnv *
1010retransformableEnvironment(JPLISAgent * agent) {
  jvmtiEnv *          retransformerEnv     = NULL((void*)0);
  jint                jnierror             = JNI_OK0;
  jvmtiCapabilities   desiredCapabilities;
  jvmtiEventCallbacks callbacks;
  jvmtiError          jvmtierror;

  if (agent->mRetransformEnvironment.mJVMTIEnv != NULL((void*)0)) {
      return agent->mRetransformEnvironment.mJVMTIEnv;
  }
  jnierror = (*agent->mJVM)->GetEnv(  agent->mJVM,
                             (void **) &retransformerEnv,
                             JVMTI_VERSION_1_1);
  if ( jnierror != JNI_OK0 ) {
      return NULL((void*)0);
  }
  jvmtierror = (*retransformerEnv)->GetCapabilities(retransformerEnv, &desiredCapabilities);
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1027);
  desiredCapabilities.can_retransform_classes = 1;
  if (agent->mNativeMethodPrefixAdded) {
      desiredCapabilities.can_set_native_method_prefix = 1;
  }

  jvmtierror = (*retransformerEnv)->AddCapabilities(retransformerEnv, &desiredCapabilities);
  if (jvmtierror != JVMTI_ERROR_NONE) {
       /* cannot get the capability, dispose of the retransforming environment */
      jvmtierror = (*retransformerEnv)->DisposeEnvironment(retransformerEnv);
      jplis_assert(jvmtierror == JVMTI_ERROR_NOT_AVAILABLE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NOT_AVAILABLE
), "jvmtierror == JVMTI_ERROR_NOT_AVAILABLE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1037);
      return NULL((void*)0);
  }
  memset(&callbacks, 0, sizeof(callbacks));
  callbacks.ClassFileLoadHook = &eventHandlerClassFileLoadHook;

  jvmtierror = (*retransformerEnv)->SetEventCallbacks(retransformerEnv,
                                                      &callbacks,
                                                      sizeof(callbacks));
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1046);
  if (jvmtierror == JVMTI_ERROR_NONE) {
      // install the retransforming environment
      agent->mRetransformEnvironment.mJVMTIEnv = retransformerEnv;
      agent->mRetransformEnvironment.mIsRetransformer = JNI_TRUE1;

      // Make it for ClassFileLoadHook handling
      jvmtierror = (*retransformerEnv)->SetEnvironmentLocalStorage(
                                                     retransformerEnv,
                                                     &(agent->mRetransformEnvironment));
      jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1056);
      if (jvmtierror == JVMTI_ERROR_NONE) {
          return retransformerEnv;
      }
  }
  return NULL((void*)0);
1062}


1065/*
*  Underpinnings for native methods
*/

1069jboolean
1070isModifiableClass(JNIEnv * jnienv, JPLISAgent * agent, jclass clazz) {
  jvmtiEnv *          jvmtienv = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jvmtiError          jvmtierror;
  jboolean            is_modifiable = JNI_FALSE0;

  jvmtierror = (*jvmtienv)->IsModifiableClass( jvmtienv,
                                               clazz,
                                               &is_modifiable);
  check_phase_ret_false(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return (jboolean
) 0; };
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1079);

  return is_modifiable;
1082}

1084jboolean
1085isRetransformClassesSupported(JNIEnv * jnienv, JPLISAgent * agent) {
  return agent->mRetransformEnvironment.mIsRetransformer;
1087}

1089void
1090setHasTransformers(JNIEnv * jnienv, JPLISAgent * agent, jboolean has) {
  jvmtiEnv *          jvmtienv = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jvmtiError          jvmtierror;

  jplis_assert(jvmtienv != NULL)JPLISAssertCondition((jboolean)(jvmtienv != ((void*)0)), "jvmtienv != NULL"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1094);
  jvmtierror = (*jvmtienv)->SetEventNotificationMode(
                                          jvmtienv,
                                          has? JVMTI_ENABLE : JVMTI_DISABLE,
                                          JVMTI_EVENT_CLASS_FILE_LOAD_HOOK,
                                          NULL((void*)0) /* all threads */);
  check_phase_ret(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return; };
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1101);
1102}

1104void
1105setHasRetransformableTransformers(JNIEnv * jnienv, JPLISAgent * agent, jboolean has) {
  jvmtiEnv *          retransformerEnv     = retransformableEnvironment(agent);
  jvmtiError          jvmtierror;

  jplis_assert(retransformerEnv != NULL)JPLISAssertCondition((jboolean)(retransformerEnv != ((void*)0
)), "retransformerEnv != NULL", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1109);
  jvmtierror = (*retransformerEnv)->SetEventNotificationMode(
                                                  retransformerEnv,
                                                  has? JVMTI_ENABLE : JVMTI_DISABLE,
                                                  JVMTI_EVENT_CLASS_FILE_LOAD_HOOK,
                                                  NULL((void*)0) /* all threads */);
  check_phase_ret(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return; };
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1116);
1117}

1119void
1120retransformClasses(JNIEnv * jnienv, JPLISAgent * agent, jobjectArray classes) {
  jvmtiEnv *  retransformerEnv     = retransformableEnvironment(agent);
  jboolean    errorOccurred        = JNI_FALSE0;
  jvmtiError  errorCode            = JVMTI_ERROR_NONE;
  jsize       numClasses           = 0;
  jclass *    classArray           = NULL((void*)0);

  /* This is supposed to be checked by caller, but just to be sure */
  if (retransformerEnv == NULL((void*)0)) {
      jplis_assert(retransformerEnv != NULL)JPLISAssertCondition((jboolean)(retransformerEnv != ((void*)0
)), "retransformerEnv != NULL", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1129);
      errorOccurred = JNI_TRUE1;
      errorCode = JVMTI_ERROR_MUST_POSSESS_CAPABILITY;
  }

  /* This was supposed to be checked by caller too */
  if (!errorOccurred && classes == NULL((void*)0)) {
      jplis_assert(classes != NULL)JPLISAssertCondition((jboolean)(classes != ((void*)0)), "classes != NULL"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1136);
      errorOccurred = JNI_TRUE1;
      errorCode = JVMTI_ERROR_NULL_POINTER;
  }

  if (!errorOccurred) {
      numClasses = (*jnienv)->GetArrayLength(jnienv, classes);
      errorOccurred = checkForThrowable(jnienv);
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1144);

      if (!errorOccurred && numClasses == 0) {
          jplis_assert(numClasses != 0)JPLISAssertCondition((jboolean)(numClasses != 0), "numClasses != 0"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1147);
          errorOccurred = JNI_TRUE1;
          errorCode = JVMTI_ERROR_NULL_POINTER;
      }
  }

  if (!errorOccurred) {
      classArray = (jclass *) allocate(retransformerEnv,
                                       numClasses * sizeof(jclass));
      errorOccurred = (classArray == NULL((void*)0));
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1157);
      if (errorOccurred) {
          errorCode = JVMTI_ERROR_OUT_OF_MEMORY;
      }
  }

  if (!errorOccurred) {
      jint index;
      for (index = 0; index < numClasses; index++) {
          classArray[index] = (*jnienv)->GetObjectArrayElement(jnienv, classes, index);
          errorOccurred = checkForThrowable(jnienv);
          jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1168);
          if (errorOccurred) {
              break;
          }

          if (classArray[index] == NULL((void*)0)) {
              jplis_assert(classArray[index] != NULL)JPLISAssertCondition((jboolean)(classArray[index] != ((void*)
0)), "classArray[index] != NULL", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1174);
              errorOccurred = JNI_TRUE1;
              errorCode = JVMTI_ERROR_NULL_POINTER;
              break;
          }
      }
  }

  if (!errorOccurred) {
      errorCode = (*retransformerEnv)->RetransformClasses(retransformerEnv,
                                                          numClasses, classArray);
      errorOccurred = (errorCode != JVMTI_ERROR_NONE);
  }

  /* Give back the buffer if we allocated it.  Throw any exceptions after.
   */
  if (classArray != NULL((void*)0)) {
      deallocate(retransformerEnv, (void*)classArray);
  }

  /* Return back if we executed the JVMTI API in a wrong phase
   */
  check_phase_ret(errorCode)if ((errorCode) == JVMTI_ERROR_WRONG_PHASE) { return; };

  if (errorCode != JVMTI_ERROR_NONE) {
      createAndThrowThrowableFromJVMTIErrorCode(jnienv, errorCode);
  }

  mapThrownThrowableIfNecessary(jnienv, redefineClassMapper);
1203}

1205/*
*  Java code must not call this with a null list or a zero-length list.
*/
1208void
1209redefineClasses(JNIEnv * jnienv, JPLISAgent * agent, jobjectArray classDefinitions) {
  jvmtiEnv*   jvmtienv                        = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jboolean    errorOccurred                   = JNI_FALSE0;
  jclass      classDefClass                   = NULL((void*)0);
  jmethodID   getDefinitionClassMethodID      = NULL((void*)0);
  jmethodID   getDefinitionClassFileMethodID  = NULL((void*)0);
  jvmtiClassDefinition* classDefs             = NULL((void*)0);
  jbyteArray* targetFiles                     = NULL((void*)0);
  jsize       numDefs                         = 0;

  jplis_assert(classDefinitions != NULL)JPLISAssertCondition((jboolean)(classDefinitions != ((void*)0
)), "classDefinitions != NULL", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1219);

  numDefs = (*jnienv)->GetArrayLength(jnienv, classDefinitions);
  errorOccurred = checkForThrowable(jnienv);
  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1223);

  if (!errorOccurred) {
      jplis_assert(numDefs > 0)JPLISAssertCondition((jboolean)(numDefs > 0), "numDefs > 0"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1226);
      /* get method IDs for methods to call on class definitions */
      classDefClass = (*jnienv)->FindClass(jnienv, "java/lang/instrument/ClassDefinition");
      errorOccurred = checkForThrowable(jnienv);
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1230);
  }

  if (!errorOccurred) {
      getDefinitionClassMethodID = (*jnienv)->GetMethodID(    jnienv,
                                              classDefClass,
                                              "getDefinitionClass",
                                              "()Ljava/lang/Class;");
      errorOccurred = checkForThrowable(jnienv);
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1239);
  }

  if (!errorOccurred) {
      getDefinitionClassFileMethodID = (*jnienv)->GetMethodID(    jnienv,
                                                  classDefClass,
                                                  "getDefinitionClassFile",
                                                  "()[B");
      errorOccurred = checkForThrowable(jnienv);
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1248);
  }

  if (!errorOccurred) {
      classDefs = (jvmtiClassDefinition *) allocate(
                                              jvmtienv,
                                              numDefs * sizeof(jvmtiClassDefinition));
      errorOccurred = (classDefs == NULL((void*)0));
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1256);
      if ( errorOccurred ) {
          createAndThrowThrowableFromJVMTIErrorCode(jnienv, JVMTI_ERROR_OUT_OF_MEMORY);
      }

      else {
          /*
           * We have to save the targetFile values that we compute so
           * that we can release the class_bytes arrays that are
           * returned by GetByteArrayElements(). In case of a JNI
           * error, we can't (easily) recompute the targetFile values
           * and we still want to free any memory we allocated.
           */
          targetFiles = (jbyteArray *) allocate(jvmtienv,
                                                numDefs * sizeof(jbyteArray));
          errorOccurred = (targetFiles == NULL((void*)0));
          jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1272);
          if ( errorOccurred ) {
              deallocate(jvmtienv, (void*)classDefs);
              createAndThrowThrowableFromJVMTIErrorCode(jnienv,
                  JVMTI_ERROR_OUT_OF_MEMORY);
          }
          else {
              jint i, j;

              // clear classDefs so we can correctly free memory during errors
              memset(classDefs, 0, numDefs * sizeof(jvmtiClassDefinition));

              for (i = 0; i < numDefs; i++) {
                  jclass      classDef    = NULL((void*)0);

                  classDef = (*jnienv)->GetObjectArrayElement(jnienv, classDefinitions, i);
                  errorOccurred = checkForThrowable(jnienv);
                  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1289);
                  if (errorOccurred) {
                      break;
                  }

                  classDefs[i].klass = (*jnienv)->CallObjectMethod(jnienv, classDef, getDefinitionClassMethodID);
                  errorOccurred = checkForThrowable(jnienv);
                  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1296);
                  if (errorOccurred) {
                      break;
                  }

                  targetFiles[i] = (*jnienv)->CallObjectMethod(jnienv, classDef, getDefinitionClassFileMethodID);
                  errorOccurred = checkForThrowable(jnienv);
                  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1303);
                  if (errorOccurred) {
                      break;
                  }

                  classDefs[i].class_byte_count = (*jnienv)->GetArrayLength(jnienv, targetFiles[i]);
                  errorOccurred = checkForThrowable(jnienv);
                  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1310);
                  if (errorOccurred) {
                      break;
                  }

                  /*
                   * Allocate class_bytes last so we don't have to free
                   * memory on a partial row error.
                   */
                  classDefs[i].class_bytes = (unsigned char*)(*jnienv)->GetByteArrayElements(jnienv, targetFiles[i], NULL((void*)0));
                  errorOccurred = checkForThrowable(jnienv);
                  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1321);
                  if (errorOccurred) {
                      break;
                  }
              }

              if (!errorOccurred) {
                  jvmtiError  errorCode = JVMTI_ERROR_NONE;
                  errorCode = (*jvmtienv)->RedefineClasses(jvmtienv, numDefs, classDefs);
                  if (errorCode == JVMTI_ERROR_WRONG_PHASE) {
                      /* insulate caller from the wrong phase error */
                      errorCode = JVMTI_ERROR_NONE;
                  } else {
                      errorOccurred = (errorCode != JVMTI_ERROR_NONE);
                      if ( errorOccurred ) {
                          createAndThrowThrowableFromJVMTIErrorCode(jnienv, errorCode);
                      }
                  }
              }

              /*
               * Cleanup memory that we allocated above. If we had a
               * JNI error, a JVM/TI error or no errors, index 'i'
               * tracks how far we got in processing the classDefs
               * array. Note:  ReleaseByteArrayElements() is safe to
               * call with a JNI exception pending.
               */
              for (j = 0; j < i; j++) {
                  if ((jbyte *)classDefs[j].class_bytes != NULL((void*)0)) {
                      (*jnienv)->ReleaseByteArrayElements(jnienv,
                          targetFiles[j], (jbyte *)classDefs[j].class_bytes,
                          0 /* copy back and free */);
                      /*
                       * Only check for error if we didn't already have one
                       * so we don't overwrite errorOccurred.
                       */
                      if (!errorOccurred) {
                          errorOccurred = checkForThrowable(jnienv);
                          jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1359);
                      }
                  }
              }
              deallocate(jvmtienv, (void*)targetFiles);
              deallocate(jvmtienv, (void*)classDefs);
          }
      }
  }

  mapThrownThrowableIfNecessary(jnienv, redefineClassMapper);
1370}

1372/* Cheesy sharing. ClassLoader may be null. */
1373jobjectArray
1374commonGetClassList( JNIEnv *            jnienv,
                  JPLISAgent *        agent,
                  jobject             classLoader,
                  ClassListFetcher    fetcher) {
  jvmtiEnv *      jvmtienv        = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jboolean        errorOccurred   = JNI_FALSE0;
  jvmtiError      jvmtierror      = JVMTI_ERROR_NONE;
  jint            classCount      = 0;
  jclass *        classes         = NULL((void*)0);
  jobjectArray    localArray      = NULL((void*)0);

  /* retrieve the classes from the JVMTI agent */
  jvmtierror = (*fetcher)( jvmtienv,
                      classLoader,
                      &classCount,
                      &classes);
  check_phase_ret_blob(jvmtierror, localArray)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return (localArray
); };
  errorOccurred = (jvmtierror != JVMTI_ERROR_NONE);
  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1392);

  if ( errorOccurred ) {
      createAndThrowThrowableFromJVMTIErrorCode(jnienv, jvmtierror);
  } else {
      localArray = getObjectArrayFromClasses( jnienv,
                                              classes,
                                              classCount);
      errorOccurred = checkForThrowable(jnienv);
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1401);

      /* do this whether or not we saw a problem */
      deallocate(jvmtienv, (void*)classes);
  }

  mapThrownThrowableIfNecessary(jnienv, mapAllCheckedToInternalErrorMapper);
  return localArray;

1410}

1412jvmtiError
1413getAllLoadedClassesClassListFetcher(    jvmtiEnv *  jvmtienv,
                                      jobject     classLoader,
                                      jint *      classCount,
                                      jclass **   classes) {
  return (*jvmtienv)->GetLoadedClasses(jvmtienv, classCount, classes);
1418}

1420jobjectArray
1421getAllLoadedClasses(JNIEnv * jnienv, JPLISAgent * agent) {
  return commonGetClassList(  jnienv,
                              agent,
                              NULL((void*)0),
                              getAllLoadedClassesClassListFetcher);
1426}

1428jvmtiError
1429getInitiatedClassesClassListFetcher(    jvmtiEnv *  jvmtienv,
                                      jobject     classLoader,
                                      jint *      classCount,
                                      jclass **   classes) {
  return (*jvmtienv)->GetClassLoaderClasses(jvmtienv, classLoader, classCount, classes);
1434}


1437jobjectArray
1438getInitiatedClasses(JNIEnv * jnienv, JPLISAgent * agent, jobject classLoader) {
  return commonGetClassList(  jnienv,
                              agent,
                              classLoader,
                              getInitiatedClassesClassListFetcher);
1443}

1445jlong
1446getObjectSize(JNIEnv * jnienv, JPLISAgent * agent, jobject objectToSize) {
  jvmtiEnv *  jvmtienv    = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jlong       objectSize  = -1;
  jvmtiError  jvmtierror  = JVMTI_ERROR_NONE;

  jvmtierror = (*jvmtienv)->GetObjectSize(jvmtienv, objectToSize, &objectSize);
  check_phase_ret_0(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return 0; };
  jplis_assert(jvmtierror == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(jvmtierror == JVMTI_ERROR_NONE
), "jvmtierror == JVMTI_ERROR_NONE", "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1453);
  if ( jvmtierror != JVMTI_ERROR_NONE ) {
      createAndThrowThrowableFromJVMTIErrorCode(jnienv, jvmtierror);
  }

  mapThrownThrowableIfNecessary(jnienv, mapAllCheckedToInternalErrorMapper);
  return objectSize;
1460}

1462void
1463appendToClassLoaderSearch(JNIEnv * jnienv, JPLISAgent * agent, jstring jarFile, jboolean isBootLoader)
1464{
  jvmtiEnv *  jvmtienv    = jvmti(agent)agent->mNormalEnvironment.mJVMTIEnv;
  jboolean    errorOutstanding;
  jvmtiError  jvmtierror;
  const char* utf8Chars;
  jsize       utf8Len;
  jboolean    isCopy;
  char        platformChars[MAXPATHLEN4096];
  int         platformLen;

  utf8Len = (*jnienv)->GetStringUTFLength(jnienv, jarFile);
  errorOutstanding = checkForAndClearThrowable(jnienv);

  if (!errorOutstanding) {
      utf8Chars = (*jnienv)->GetStringUTFChars(jnienv, jarFile, &isCopy);
      errorOutstanding = checkForAndClearThrowable(jnienv);

      if (!errorOutstanding && utf8Chars != NULL((void*)0)) {
          /*
           * JVMTI spec'ed to use modified UTF8. At this time this is not implemented
           * the platform encoding is used.
           */
          platformLen = convertUtf8ToPlatformString((char*)utf8Chars, utf8Len, platformChars, MAXPATHLEN4096);
          if (platformLen < 0) {
              createAndThrowInternalError(jnienv);
              (*jnienv)->ReleaseStringUTFChars(jnienv, jarFile, utf8Chars);
              return;
          }

          (*jnienv)->ReleaseStringUTFChars(jnienv, jarFile, utf8Chars);
          errorOutstanding = checkForAndClearThrowable(jnienv);

          if (!errorOutstanding) {

              if (isBootLoader) {
                  jvmtierror = (*jvmtienv)->AddToBootstrapClassLoaderSearch(jvmtienv, platformChars);
              } else {
                  jvmtierror = (*jvmtienv)->AddToSystemClassLoaderSearch(jvmtienv, platformChars);
              }
              check_phase_ret(jvmtierror)if ((jvmtierror) == JVMTI_ERROR_WRONG_PHASE) { return; };

              if ( jvmtierror != JVMTI_ERROR_NONE ) {
                  createAndThrowThrowableFromJVMTIErrorCode(jnienv, jvmtierror);
              }
          }
      }
  }

  mapThrownThrowableIfNecessary(jnienv, mapAllCheckedToInternalErrorMapper);
1513}

1515/*
*  Set the prefixes used to wrap native methods (so they can be instrumented).
*  Each transform can set a prefix, any that have been set come in as prefixArray.
*  Convert them in native strings in a native array then call JVM TI.
*  One a given call, this function handles either the prefixes for retransformable
*  transforms or for normal transforms.
*/
1522void
1523setNativeMethodPrefixes(JNIEnv * jnienv, JPLISAgent * agent, jobjectArray prefixArray,
                      jboolean isRetransformable) {
  jvmtiEnv*   jvmtienv;
  jvmtiError  err                             = JVMTI_ERROR_NONE;
  jsize       arraySize;
  jboolean    errorOccurred                   = JNI_FALSE0;

  jplis_assert(prefixArray != NULL)JPLISAssertCondition((jboolean)(prefixArray != ((void*)0)), "prefixArray != NULL"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1530);

  if (isRetransformable) {
      jvmtienv = agent->mRetransformEnvironment.mJVMTIEnv;
  } else {
      jvmtienv = agent->mNormalEnvironment.mJVMTIEnv;
  }
  arraySize = (*jnienv)->GetArrayLength(jnienv, prefixArray);
  errorOccurred = checkForThrowable(jnienv);
  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1539);

  if (!errorOccurred) {
      /* allocate the native to hold the native prefixes */
      const char** prefixes = (const char**) allocate(jvmtienv,
                                                      arraySize * sizeof(char*));
      /* since JNI ReleaseStringUTFChars needs the jstring from which the native
       * string was allocated, we store them in a parallel array */
      jstring* originForRelease = (jstring*) allocate(jvmtienv,
                                                      arraySize * sizeof(jstring));
      errorOccurred = (prefixes == NULL((void*)0) || originForRelease == NULL((void*)0));
      jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1550);
      if ( errorOccurred ) {
          createAndThrowThrowableFromJVMTIErrorCode(jnienv, JVMTI_ERROR_OUT_OF_MEMORY);
      }
      else {
          jint inx = 0;
          jint i;
          for (i = 0; i < arraySize; i++) {
              jstring      prefixStr  = NULL((void*)0);
              const char*  prefix;
              jsize        prefixLen;
              jboolean     isCopy;

              prefixStr = (jstring) ((*jnienv)->GetObjectArrayElement(jnienv,
                                                                      prefixArray, i));
              errorOccurred = checkForThrowable(jnienv);
              jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1566);
              if (errorOccurred) {
                  break;
              }
              if (prefixStr == NULL((void*)0)) {
                  continue;
              }

              prefixLen = (*jnienv)->GetStringUTFLength(jnienv, prefixStr);
              errorOccurred = checkForThrowable(jnienv);
              jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1576);
              if (errorOccurred) {
                  break;
              }

              if (prefixLen > 0) {
                  prefix = (*jnienv)->GetStringUTFChars(jnienv, prefixStr, &isCopy);
                  errorOccurred = checkForThrowable(jnienv);
                  jplis_assert(!errorOccurred)JPLISAssertCondition((jboolean)(!errorOccurred), "!errorOccurred"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1584);
                  if (!errorOccurred && prefix != NULL((void*)0)) {
                      prefixes[inx] = prefix;
                      originForRelease[inx] = prefixStr;
                      ++inx;
                  }
              }
          }

          err = (*jvmtienv)->SetNativeMethodPrefixes(jvmtienv, inx, (char**)prefixes);
          /* can be called from any phase */
          jplis_assert(err == JVMTI_ERROR_NONE)JPLISAssertCondition((jboolean)(err == JVMTI_ERROR_NONE), "err == JVMTI_ERROR_NONE"
, "/home/daniel/Projects/java/jdk/src/java.instrument/share/native/libinstrument/JPLISAgent.c"
, 1595);

          for (i = 0; i < inx; i++) {
            (*jnienv)->ReleaseStringUTFChars(jnienv, originForRelease[i], prefixes[i]);
          }
      }
      deallocate(jvmtienv, (void*)prefixes);
      deallocate(jvmtienv, (void*)originForRelease);
  }
1604}