set VS2010DIR=E:/BUILDSDK/VC/VC/
set WINDOWSSDKDIR=E:/BUILDSDK/v7.0A/
set ALT_DXSDK_PATH=E:/BUILDSDK/DXSDK/
set FREE_TYPE=E:/BUILDSDK/freetype-2.9.1/
set CYGWINDIR=E:/cygwin64/
set ALT_BOOTDIR=E:/BUILDSDK/OpenJDK7/

:: set DXSDK
:: set ALT_DXSDK_LIB_PATH=%ALT_DXSDK_PATH%Lib\x64
:: SET DXSDK_INCLUDE_PATH=%ALT_DXSDK_PATH%Include
SET DXSDK_DIR=%ALT_DXSDK_PATH%

:: set freetype
set ALT_FREETYPE_HEADERS_PATH=%FREE_TYPE%include
set ALT_FREETYPE_LIB_PATH=%FREE_TYPE%lib

set INCLUDE=%VS2010DIR%include;%FREE_TYPE%include;%WINDOWSSDKDIR%Include;%ALT_DXSDK_PATH%Include
set LIB=%VS2010DIR%lib\amd64;%WINDOWSSDKDIR%Lib\x64

set VS100COMNTOOLS=%VS2010DIR%../Common7/Tools/
set Path=%VS2010DIR%bin\amd64;%ALT_DXSDK_PATH%Utilities\Bin\x64;%WindowsSdkDir%bin\NETFX 4.0 Tools;%CYGWINDIR%bin;%PATH%

bash ./configure --with-boot-jdk=C:\\"Program Files"\\Java\\jdk1.8.0_202 --with-target-bits=64 --enable-debug-symbols --with-debug-level=slowdebug --with-freetype=C:/BUILD/freetype-2.9.1 OBJCOPY=gobjcopy

bash ./configure --with-target-bits=64 --enable-debug-symbols --with-debug-level=slowdebug OBJCOPY=gobjcopy

make JOBS=8 CONF=windows-x86_64-normal-server-slowdebug

-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=9090 # 旧版 
-agentlib:jdwp=transport=dt_socket,server=y,address=9090 # 新版，在更新的版本中需要用*:9090指定绑定地址

typedef struct {
    jvmtiEventVMInit VMInit; // JVM初始化完成时，此时可以调用所有JNI和JVMTI
    jvmtiEventVMDeath VMDeath;  // JVM终止时
    jvmtiEventThreadStart ThreadStart;  // 创建新线程时发生，这在新线程初始化之前
    jvmtiEventThreadEnd ThreadEnd;  // 线程终止时
    jvmtiEventClassFileLoadHook ClassFileLoadHook;  // 类数据被读取但是还未被解析为Class，或者类被修改了
    jvmtiEventClassLoad ClassLoad;  // 第一次加载类时(原生类/数组类不会发生)，注意此时类还未完成加载
    jvmtiEventClassPrepare ClassPrepare;  // 类准备完成时，还未执行任何代码，但是字段方法可用
    jvmtiEventVMStart VMStart;  // JVM启动时，此时可调用JNI和该阶段可用的部分JVMTI
    jvmtiEventException Exception;  // 当检测到异常时
    jvmtiEventExceptionCatch ExceptionCatch;  // 当捕获异常时
    jvmtiEventSingleStep SingleStep; 
    jvmtiEventFramePop FramePop;  // 弹出一个栈帧时，如运行返回或向上抛出异常
    jvmtiEventBreakpoint Breakpoint;  // 在运行到SetBreakpoint指定的位置时发生
    jvmtiEventFieldAccess FieldAccess;  // 访问某个域时，如watch
    jvmtiEventFieldModification FieldModification;  // 修改某个域时
    jvmtiEventMethodEntry MethodEntry;  // 进入Java/Native方法时
    jvmtiEventMethodExit MethodExit;  // 退出方法时，包括正常或异常返回
    jvmtiEventNativeMethodBind NativeMethodBind;  // 当Native方法被绑定时，如调用RegisterNatives或第一次调用Native方法
    //...
} jvmtiEventCallbacks;

#include <jvmti.h>

JNIEXPORT jint JNICALL 
Agent_OnLoad(JavaVM *vm, char *options, void *reserved); // 启动时调用

JNIEXPORT jint JNICALL 
Agent_OnAttach(JavaVM* vm, char *options, void *reserved); // 以attach加载时调用

JNIEXPORT void JNICALL 
Agent_OnUnload(JavaVM *vm); // 卸载时调用

public static void premain(String agentArgs, Instrumentation inst);
public static void premain(String agentArgs);

public static void agentmain(String agentArgs, Instrumentation inst);
public static void agentmain(String agentArgs);

Premain-Class:me.betamao.instrument.StartUpTest
Agent-Class:me.betamao.instrument.AttachTest
Can-Redefine-Classes:true
...

JNIEXPORT jint JNICALL
DEF_Agent_OnLoad(JavaVM *vm, char *tail, void * reserved) { // DEF_Agent_OnLoad宏展开就是Agent_OnLoad
    ...
    /* 创建JPLISAgent，它里面会保存一些数据，如要运行的函数名，一些参数，一些权限信息等 */
    initerror = createNewJPLISAgent(vm, &agent);
    /* 解析参数，获取javaagent文件 */
    parseArgumentTail(tail, &jarfile, &options)
    /* 解析javaagent里的属性信息，下面会提 */
    attributes = readAttributes(jarfile);
    /* 根据javaagent里的属性信息和剩余的参数信息设置JPLISAgent */
    premainClass = getAttribute(attributes, "Premain-Class");
    agent->mJarfile = jarfile;
    premainClass = strdup(premainClass);
    bootClassPath = getAttribute(attributes, "Boot-Class-Path");
    appendBootClassPath(agent, jarfile, bootClassPath);
    convertCapabilityAttributes(attributes, agent);
    initerror = recordCommandLineData(agent, premainClass, options);
    ...
}

JPLISInitializationError
initializeJPLISAgent(   JPLISAgent *    agent,
                        JavaVM *        vm,
                        jvmtiEnv *      jvmtienv) {
    jvmtiError      jvmtierror = JVMTI_ERROR_NONE;
    jvmtiPhase      phase;
    /* 把agent存入mNormalEnvironment并将mNormalEnvironment存入jvmtienv，这样之后就能重新获取了*/
    agent->mJVM                                      = vm;
    agent->mNormalEnvironment.mJVMTIEnv              = jvmtienv;
    agent->mNormalEnvironment.mAgent                 = agent;
    //...

    jvmtierror = (*jvmtienv)->SetEnvironmentLocalStorage(
                                            jvmtienv,
                                            &(agent->mNormalEnvironment));
    /* 查看当前的阶段，只有在启动时指定的才会继续，而且-javaagent要早于-jar */
    jvmtierror = (*jvmtienv)->GetPhase(jvmtienv, &phase);
    /* can be called from any phase */
    jplis_assert(jvmtierror == JVMTI_ERROR_NONE);
    if (phase == JVMTI_PHASE_LIVE) {
        return JPLIS_INIT_ERROR_NONE;
    }

    /* 这里注册了一个VMInit的回调事件 */
    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);
        jplis_assert(jvmtierror == JVMTI_ERROR_NONE);
    }
    //...
}

void JNICALL
eventHandlerVMInit( jvmtiEnv *      jvmtienv,
                    JNIEnv *        jnienv,
                    jthread         thread) {
    //...
    /* 获取之前存储的agent */
    environment = getJPLISEnvironment(jvmtienv);
    JPLISAgent * agent = environment->mAgent;
    /* 把agent的文件路径添加到类路径里 */
    appendClassPath(agent, agent->mJarfile)
    /* 开始执行agent */
    success = processJavaStart( environment->mAgent, jnienv);
}

jboolean
processJavaStart(   JPLISAgent *    agent,
                    JNIEnv *        jnienv) {
    jboolean    result;

    /* 创建InstrumentationImpl对象实例，就是普通JNI调用，并把实例和相关的方法绑定到agent上 */
    result = createInstrumentationImpl(jnienv, agent);
    /* 在这一步，它监听了ClassFileLoadHook事件，代码和上面的监听类似，它实际做的是当类加载前/修改时，执行注册的transformer链 */
    result = setLivePhaseEventHandlers(agent);
    /* 这又是一个JNI调用，它调用了PreMain方法，传入的参数是上面创建的InstrumentationImpl实例 */
    result = startJavaAgent(agent, jnienv,
                            agent->mAgentClassName, agent->mOptionsString,
                            agent->mPremainCaller);
    //...
}

JNIEXPORT jint JNICALL
DEF_Agent_OnAttach(JavaVM* vm, char *args, void * reserved) {
        /* 与Onload类似 */
        convertCapabilityAttributes(attributes, agent);
        /* 此后它不再是使用事件回调(因为已经初始化完了)，而是直接调用 */
        success = createInstrumentationImpl(jni_env, agent);
        success = setLivePhaseEventHandlers(agent);
        /* 注意这里的参数不再是PreMain而是AgentMain了 */
        success = startJavaAgent(agent,
                                 jni_env,
                                 agentClass,
                                 options,
                                 agent->mAgentmainCaller);
        //...
}

public static void fixLineNumber(String inputFilePath, String outputFilePath, HashMap<String, ArrayList<Pair<Integer, Integer>>> lineNumberMapping) {
    ClassParser classParser = new ClassParser(inputFilePath);
    JavaClass javaClass = null;
    try {
      javaClass = classParser.parse();
    } catch (IOException e) {
      e.printStackTrace();
      return;
    }

    // 1. 先获取LineNumberTable的位置，若没有就增加一个常量来存放
    Constant[] constantPoolArr = javaClass.getConstantPool().getConstantPool();
    int lineTableConstIndex = 0;
    for (; lineTableConstIndex < constantPoolArr.length; lineTableConstIndex++) {
      Constant constant = constantPoolArr[lineTableConstIndex];
      if (constant instanceof ConstantUtf8 && ((ConstantUtf8) constant).getBytes().equals("LineNumberTable")) {
        break;
      }
    }
    if (lineTableConstIndex == constantPoolArr.length) {
      Constant[] constants = new Constant[lineTableConstIndex + 1];
      System.arraycopy(constantPoolArr, 0, constants, 0, constantPoolArr.length);
      constants[lineTableConstIndex] = new ConstantUtf8("LineNumberTable");
      org.apache.bcel.classfile.ConstantPool newConsTantPool = new org.apache.bcel.classfile.ConstantPool(constants);
      javaClass.setConstantPool(newConsTantPool);
    }
    org.apache.bcel.classfile.ConstantPool constantPool = javaClass.getConstantPool();
    // 2. 将符号存入表中
    for (Method method : javaClass.getMethods()) {
      String qualifyName = method.getName() + ' ' + method.getSignature();
      if (!lineNumberMapping.containsKey(qualifyName)) {
        continue;
      }
      ArrayList<Pair<Integer, Integer>> lines = lineNumberMapping.get(qualifyName);
      LineNumber[] lineNumbers = new LineNumber[lines.size()];
      int j = 0;
      for (Pair<Integer, Integer> row : lines) {
        lineNumbers[j++] = new LineNumber(row.getKey(), row.getValue());
      }
      LineNumberTable lineNumberTable = new LineNumberTable(lineTableConstIndex, lineNumbers.length * 4 + 2, lineNumbers, constantPool);
      Attribute[] attributes = method.getCode().getAttributes();
      int i = 0;
      // 若之前有行号则直接覆盖
      for (; i < attributes.length; i++) {
        if (attributes[i] instanceof LineNumberTable) {
          attributes[i] = lineNumberTable;
          break;
        }
      }
      // 否则新增行号属性
      if (i == attributes.length) {
        Attribute[] newAttributes = new Attribute[attributes.length + 1];
        System.arraycopy(attributes, 0, newAttributes, 0, attributes.length);
        newAttributes[attributes.length] = lineNumberTable;
        method.getCode().setAttributes(newAttributes);
      }
    }
    try {
      javaClass.dump(outputFilePath);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }