/*

 * Copyright (c) 2007, 2018, 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.

 *

 * 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.

 */

#include <string.h>

#include "jvmti.h"

#include "agent_common.h"

#include "jni_tools.h"

#include "jvmti_tools.h"

#ifdef __cplusplus

extern "C" {

#endif

/* ============================================================================= */

static jlong timeout = 0;

#define INFO_NONE       0x00

#define INFO_ALL        0xFF

#define INFO_OBJREF     0x01

#define INFO_STACKREF   0x02

#define INFO_HEAPROOT   0x04

#define INFO_HEAPOBJ    0x08

static unsigned int info = INFO_ALL;

#define DEBUGEE_CLASS_NAME      "nsk/jvmti/unit/FollowReferences/followref003"

#define ROOT_OBJECT_CLASS_NAME  "nsk/jvmti/unit/FollowReferences/followref003RootTestedClass"

#define ROOT_OBJECT_CLASS_SIG   "L"ROOT_OBJECT_CLASS_NAME";"

#define CHAIN_OBJECT_CLASS_NAME "nsk/jvmti/unit/FollowReferences/followref003TestedClass"

#define CHAIN_OBJECT_CLASS_SIG  "L"CHAIN_OBJECT_CLASS_NAME";"

#define OBJECT_FIELD_NAME               "object"

#define REACHABLE_CHAIN_FIELD_NAME      "reachableChain"

#define UNREACHABLE_CHAIN_FIELD_NAME    "unreachableChain"

#define TAIL_FIELD_NAME                 "tail"

#define DEFAULT_CHAIN_LENGTH 3

#define MAXDEPTH 50

#define MAXSLOT  16

typedef struct ObjectDescStruct {

    jlong tag;

    jlong class_tag;

    jlong exp_class_tag;

    jint exp_found;

    jint found;

} ObjectDesc;

static int chainLength   = 0;

static int objectsCount  = 0;

static int fakeUserData  = 0;

static int userDataError = 0;

static ObjectDesc* objectDescList = NULL;

#define TARG_THREAD_TAG  11

#define FIRST_THREAD_TAG (TARG_THREAD_TAG + 1)

#define TARG_FRAME_DEPTH  1

static jlong rootClassTag   = 9;

static jlong chainClassTag  = 99;

static jlong thrObjectTag   = FIRST_THREAD_TAG;

static jlong rootObjectTag  = 55;

static jlong chainObjectTag = 100;

/* Java method frame slots interesting to check */

#define ARGV_STRING_ARR_SLOT   1

#define FIRST_PRIM_ARR_SLOT    3

#define LAST_PRIM_ARR_SLOT     10

#define DUMMY_STRING_ARR_SLOT  11

static jvmtiHeapCallbacks heapCallbacks = {0};

static const char* ref_kind_str[28] = {

   "unknown_0",

   "REFERENCE_CLASS",

   "REFERENCE_FIELD",

   "REFERENCE_ARRAY_ELEMENT",

   "REFERENCE_CLASS_LOADER",

   "REFERENCE_SIGNERS",

   "REFERENCE_PROTECTION_DOMAIN",

   "REFERENCE_INTERFACE",

   "REFERENCE_STATIC_FIELD",

   "REFERENCE_CONSTANT_POOL",

   "unknown_10", "unknown_11", "unknown_12",

   "unknown_13", "unknown_14", "unknown_15", "unknown_16",

   "unknown_17", "unknown_18", "unknown_19", "unknown_20",

   "REFERENCE_JNI_GLOBAL",

   "REFERENCE_SYSTEM_CLASS",

   "REFERENCE_MONITOR",

   "REFERENCE_STACK_LOCAL",

   "REFERENCE_JNI_LOCAL",

   "REFERENCE_THREAD",

   "REFERENCE_OTHER"

};

#define DEREF(ptr) (((ptr) == NULL ? 0 : *(ptr)))

/* ============================================================================= */

/** Obtain chain of tested objects and tag them recursively. */

static int getChainObjects(jvmtiEnv* jvmti, JNIEnv* jni, jobject firstObject,

                           jfieldID firstField, const char firstFieldName[],

                           jfieldID nextField, const char nextFieldName[],

                           int count, ObjectDesc objectDescList[],

                           jlong tag, int reachable) {

    jobject obj = NULL;

    jlong objTag = (reachable ? tag : -tag);

    if (count <= 0)

        return NSK_TRUE;

    count--;

    tag++;

    if (!NSK_JNI_VERIFY(jni, (obj =

            NSK_CPP_STUB3(GetObjectField, jni, firstObject, firstField)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    objectDescList[count].tag = objTag;

    if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(SetTag, jvmti, obj, objTag))) {

        nsk_jvmti_setFailStatus();

    }

    printf("        tag=%-5ld object=0x%p\n", (long)objTag, (void*)obj);

    fflush(0);

    if (!getChainObjects(jvmti, jni, obj, nextField, nextFieldName,

                                nextField, nextFieldName,

                                count, objectDescList, tag, reachable)) {

        return NSK_FALSE;

    }

    NSK_TRACE(NSK_CPP_STUB2(DeleteLocalRef, jni, obj));

    return NSK_TRUE;

}

/** Obtain all tested objects from debugee class and tag them recursively. */

static int getTestedObjects(jvmtiEnv* jvmti, JNIEnv* jni, int chainLength,

                            int *objectsCount, ObjectDesc* *objectDescList,

                            jobject* rootObject) {

    jclass debugeeClass = NULL;

    jclass rootObjectClass = NULL;

    jclass chainObjectClass = NULL;

    jfieldID objectField = NULL;

    jfieldID reachableChainField = NULL;

    jfieldID unreachableChainField = NULL;

    jfieldID tailField = NULL;

    *objectsCount = 1 + 2 * chainLength;

    printf("Allocate memory for objects list: %d objects\n", *objectsCount);

    fflush(0);

    if (!NSK_JVMTI_VERIFY(

            NSK_CPP_STUB3(Allocate, jvmti, (*objectsCount * sizeof(ObjectDesc)),

                                             (unsigned char**)objectDescList))) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... allocated array: 0x%p\n", (void*)objectDescList);

    fflush(0);

    {

        int k;

        for (k = 0; k < *objectsCount; k++) {

            (*objectDescList)[k].tag = 0;

            (*objectDescList)[k].exp_class_tag = chainClassTag;

            (*objectDescList)[k].exp_found = 0;

            (*objectDescList)[k].found = 0;

        }

    }

    (*objectDescList)[0].exp_class_tag = rootClassTag;

    printf("Find debugee class: %s\n", DEBUGEE_CLASS_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (debugeeClass =

            NSK_CPP_STUB2(FindClass, jni, DEBUGEE_CLASS_NAME)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... found class: 0x%p\n", (void*)debugeeClass);

    printf("Find root object class: %s\n", ROOT_OBJECT_CLASS_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (rootObjectClass =

            NSK_CPP_STUB2(FindClass, jni, ROOT_OBJECT_CLASS_NAME)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... found class: 0x%p\n", (void*)rootObjectClass);

    if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(SetTag, jvmti, rootObjectClass, rootClassTag))) {

        nsk_jvmti_setFailStatus();

    }

    printf("        tag=%-5ld rootClass=0x%p\n",

           (long)rootClassTag, (void*)rootObjectClass);

    printf("Find chain object class: %s\n", CHAIN_OBJECT_CLASS_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (chainObjectClass =

            NSK_CPP_STUB2(FindClass, jni, CHAIN_OBJECT_CLASS_NAME)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... found class: 0x%p\n",

           (void*)chainObjectClass);

    if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(SetTag, jvmti, chainObjectClass, chainClassTag))) {

        nsk_jvmti_setFailStatus();

    }

    printf("        tag=%-5ld chainClass=0x%p\n",

           (long)chainClassTag, (void*)chainObjectClass);

    printf("Find static field in debugee class: %s\n", OBJECT_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (objectField =

            NSK_CPP_STUB4(GetStaticFieldID, jni, debugeeClass,

                            OBJECT_FIELD_NAME, ROOT_OBJECT_CLASS_SIG)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... got fieldID: 0x%p\n", (void*)objectField);

    printf("Find instance field in root object class: %s\n", REACHABLE_CHAIN_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (reachableChainField =

            NSK_CPP_STUB4(GetFieldID, jni, rootObjectClass,

                        REACHABLE_CHAIN_FIELD_NAME, CHAIN_OBJECT_CLASS_SIG)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... got fieldID: 0x%p\n", (void*)reachableChainField);

    printf("Find instance field in root object class: %s\n", UNREACHABLE_CHAIN_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (unreachableChainField =

            NSK_CPP_STUB4(GetFieldID, jni, rootObjectClass,

                          UNREACHABLE_CHAIN_FIELD_NAME, CHAIN_OBJECT_CLASS_SIG)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... got fieldID: 0x%p\n", (void*)unreachableChainField);

    printf("Find instance field in chain object class: %s\n", TAIL_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (tailField =

            NSK_CPP_STUB4(GetFieldID, jni, chainObjectClass,

                          TAIL_FIELD_NAME, CHAIN_OBJECT_CLASS_SIG)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... got fieldID: 0x%p\n", (void*)tailField);

    printf("Get root object from static field: %s\n", OBJECT_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*rootObject =

            NSK_CPP_STUB3(GetStaticObjectField, jni, debugeeClass,

                                                    objectField)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... got object: 0x%p\n", (void*)*rootObject);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*rootObject =

            NSK_CPP_STUB2(NewGlobalRef, jni, *rootObject)) != NULL)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("  ... global ref: 0x%p\n", (void*)*rootObject);

    printf("Obtain and tag chain objects:\n");

    printf("    root tested object\n");

    fflush(0);

    if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(SetTag, jvmti, *rootObject, rootObjectTag))) {

        nsk_jvmti_setFailStatus();

    }

    printf("        tag=%-5ld object=0x%p\n",

           (long)rootObjectTag, (void*)*rootObject);

    /* Root object must be reported 1 time */

    (*objectDescList)[0].exp_found = 1;

    (*objectDescList)[0].tag = rootObjectTag;

    printf("    reachable objects chain: %d objects\n", chainLength);

    fflush(0);

    if (!getChainObjects(jvmti, jni, *rootObject,

                                reachableChainField, REACHABLE_CHAIN_FIELD_NAME,

                                tailField, TAIL_FIELD_NAME,

                                chainLength, (*objectDescList) + 1,

                                chainObjectTag, NSK_TRUE)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    /* First unreachable object must be reported once

     * as JVMTI_HEAP_REFERENCE_STACK_LOCAL */

    (*objectDescList)[2 * chainLength].exp_found = 1;

    printf("    unreachable objects chain: %d objects\n", chainLength);

    if (!getChainObjects(jvmti, jni, *rootObject,

                                unreachableChainField, UNREACHABLE_CHAIN_FIELD_NAME,

                                tailField, TAIL_FIELD_NAME,

                                chainLength, (*objectDescList) + 1 + chainLength,

                                chainObjectTag, NSK_FALSE)) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    return NSK_TRUE;

}

/** Check if tagged objects were iterated. */

static int checkTestedObjects(jvmtiEnv* jvmti, JNIEnv* jni,

                              int chainLength, ObjectDesc objectDescList[]) {

    int success = NSK_TRUE;

    int i, idx;

    printf("Following tagged objects were iterated:\n");

    printf("Root tested object:\n");

    printf("   tag:                 %ld\n"

           "   expected to iterate: %d times\n"

           "   iterated:            %d times\n",

           (long) objectDescList[0].tag,

                  objectDescList[0].exp_found,

                  objectDescList[0].found);

    if (objectDescList[0].found != objectDescList[0].exp_found) {

        NSK_COMPLAIN1("Root tested object unexpectedly iterated %d times\n",

                      objectDescList[0].found);

        nsk_jvmti_setFailStatus();

    }

    printf("\nReachable objects:\n");

    fflush(0);

    for (i = 0; i < chainLength; i++) {

        idx = i + 1;

        printf("Reachable object:\n"

               "   tag:                 %-3ld\n"

               "   expected to iterate: %d times\n"

               "   iterated:            %d times\n",

                (long) objectDescList[idx].tag,

                       objectDescList[idx].exp_found,

                       objectDescList[idx].found);

        if (objectDescList[i + 1].found <= 0 && objectDescList[i + 1].exp_found > 0) {

            NSK_COMPLAIN0("Reachable object was not iterated\n");

            nsk_jvmti_setFailStatus();

        }

        if (objectDescList[idx].found != objectDescList[idx].exp_found) {

            NSK_COMPLAIN0("Reachable object was iterated unexpected number of times\n");

            nsk_jvmti_setFailStatus();

        }

    }

    printf("\nUnreachable objects:\n");

    for (i = 0; i < chainLength; i++) {

        idx = i + 1 + chainLength;

        printf("Unreachable object:\n"

               "   tag:                 %ld\n"

               "   expected to iterate: %d times\n"

               "   iterated:            %d times\n",

                (long) objectDescList[idx].tag,

                       objectDescList[idx].exp_found,

                       objectDescList[idx].found);

        if (objectDescList[idx].found > 0 && objectDescList[idx].exp_found == 0) {

            NSK_COMPLAIN0("Unreachable object was iterated\n");

            nsk_jvmti_setFailStatus();

        }

        fflush(0);

    }

    return NSK_TRUE;

}

/** Release references to the tested objects and free allocated memory. */

static int releaseTestedObjects(jvmtiEnv* jvmti, JNIEnv* jni, int chainLength,

                                ObjectDesc* objectDescList, jobject rootObject) {

    if (rootObject != NULL) {

        printf("Release object reference to root tested object: 0x%p\n", rootObject);

        NSK_TRACE(NSK_CPP_STUB2(DeleteGlobalRef, jni, rootObject));

    }

    if (objectDescList != NULL) {

        printf("Deallocate objects list: 0x%p\n", (void*)objectDescList);

        if (!NSK_JVMTI_VERIFY(

            NSK_CPP_STUB2(Deallocate, jvmti, (unsigned char*)objectDescList))) {

            nsk_jvmti_setFailStatus();

        }

    }

    fflush(0);

    return NSK_TRUE;

}

/* ============================================================================= */

/* Some diagnostics happen in the first FollowReferences call only */

static int first_followref = 1;

typedef struct ThreadDescStruct {

    jlong tag;

    jlong id;

} ThreadDesc;

#define MAX_THREADS 1024

static ThreadDesc thrDesc [MAX_THREADS] = {{0}};

static jlong registerThread(jlong thr_id, jlong thr_tag) {

    if (thr_id <= 0 || thr_id >= MAX_THREADS) {

        NSK_COMPLAIN1("Unexpected thread ID: %ld\n", thr_id);

        nsk_jvmti_setFailStatus();

        return 0;

    }

    if (thrDesc[thr_id].id == 0) {

        /* need to set the first occurence info */

        thrDesc[thr_id].id  = thr_id;

        thrDesc[thr_id].tag = thr_tag;

    } else if (thr_tag != thrDesc[thr_id].tag) {

        NSK_COMPLAIN3("Thread tag doesn't match the first occurence: thr_id= %ld\n"

               "\t first thr_tag=%#lx, curr thr_tag=%#lx\n",

               thr_id, thrDesc[thr_id].tag, thr_tag);

        nsk_jvmti_setFailStatus();

        return 0;

    }

    return thr_id;

} /* registerThread */

typedef struct FrameDescStruct {

    jlong     thr_id;

    jint      depth;

    jmethodID method;

} FrameDesc;

#define MAX_FRAMES  256

static FrameDesc frameDesc[MAX_FRAMES] = {{0}};

static int curr_frame_id = 0;  /* Index 0 should not be used */

/* returns frame slot number in the table of frames */

static int registerFrame(jlong thr_id, jint depth, jmethodID method,

                         jvmtiHeapReferenceKind ref_kind)

{

    int idx;

    int failed = 0;

    FrameDesc *fr;

    if (depth < 0 || depth > MAXDEPTH) {

        NSK_COMPLAIN1("Incorrect frame depth: %ld\n", depth);

        failed = 1;

    }

    /* JNI_LOCAL references from native methods may not have a jmethodID.

     * (Do we have to clarify this in the JVMTI spec?)

     * Do not consider the test as failing in such a case.

     */

    if (method == NULL && ref_kind != JVMTI_HEAP_REFERENCE_JNI_LOCAL) {

        NSK_COMPLAIN0("methodID must not be NULL\n");

        failed = 1;

    }

    if (failed) {

        nsk_jvmti_setFailStatus();

        return 0;

    }

    /* Check if this frame was registered */

    for (idx = 1; idx <= curr_frame_id; idx++) {

        fr = &frameDesc[idx];

        if (fr->thr_id == thr_id && fr->depth == depth && fr->method == method) {

            return idx;

        }

    }

    if (++curr_frame_id >= MAX_FRAMES) {

        NSK_COMPLAIN1("Internal: Insufficient frames table size: %ld\n", MAX_FRAMES);

        return 0;

    }

    fr = &frameDesc[curr_frame_id];

    fr->thr_id = thr_id;

    fr->depth  = depth;

    fr->method = method;

    return curr_frame_id;

} /* registerFrame */

typedef struct LocalDescStruct {

    jint      frame_id;

    jlocation location;

    jint      slot;

    jlong     tag;

} LocalDesc;

#define MAX_LOCALS   100

static LocalDesc locDesc [MAX_LOCALS] = {{0}};

static int curr_local_idx = 0;  /* Index 0 should not be used */

/* returns frame slot number in the table of frames */

static int registerLocal(jint frame_id, jlocation location, jint slot, jlong tag) {

    int idx;

    LocalDesc *loc;

    int failed = 0;