/*

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

#include "jvmti.h"

#include "agent_common.h"

#include "jni_tools.h"

#include "jvmti_tools.h"

extern "C" {

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

static jlong timeout = 0;

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

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

#define ROOT_OBJECT_CLASS_SIG   "L" ROOT_OBJECT_CLASS_NAME ";"

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

#define CHAIN_OBJECT_CLASS_SIG  "L" CHAIN_OBJECT_CLASS_NAME ";"

#define OBJECT_FIELD_NAME               "rootObject"

#define REACHABLE_CHAIN_FIELD_NAME      "reachableChain"

#define UNREACHABLE_CHAIN_FIELD_NAME    "unreachableChain"

#define NEXT_FIELD_NAME                 "next"

#define DEFAULT_CHAIN_LENGTH 3

#define FULL_32_BIT_MASK     0xFFFFFFFF

typedef struct ObjectDescStruct {

    jlong tag;           /* Tag of the object */

    jlong exp_class_tag; /* Expected tag of the object class */

    jlong class_tag;     /* Reported tag of the object class */

    jint  exp_found;     /* Expected number of iterations through the object */

    jint  found;         /* Reported number of iterations through the object */

} ObjectDesc;

static int chainLength   = 0;

static int objectsCount  = 0;

static int fakeUserData  = 0;

static int userDataError = 0;

static ObjectDesc* objectDescList = NULL;

static const jlong ROOT_CLASS_TAG   = 9;

static const jlong CHAIN_CLASS_TAG  = 99;

static const jlong ROOT_OBJECT_TAG  = 10;

static const jlong CHAIN_OBJECT_TAG = 100;

static jvmtiHeapCallbacks heapCallbacks;

/* This array has to be up-to-date with the jvmtiHeapReferenceKind enum */

static const char* ref_kind_str[28] = {

   "unknown_0",

   "JVMTI_HEAP_REFERENCE_CLASS",

   "JVMTI_HEAP_REFERENCE_FIELD",

   "JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT",

   "JVMTI_HEAP_REFERENCE_CLASS_LOADER",

   "JVMTI_HEAP_REFERENCE_SIGNERS",

   "JVMTI_HEAP_REFERENCE_PROTECTION_DOMAIN",

   "JVMTI_HEAP_REFERENCE_INTERFACE",

   "JVMTI_HEAP_REFERENCE_STATIC_FIELD",

   "JVMTI_HEAP_REFERENCE_CONSTANT_POOL",

   "JVMTI_HEAP_REFERENCE_SUPERCLASS",

   "unknown_11", "unknown_12", "unknown_13", "unknown_14", "unknown_15",

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

   "JVMTI_HEAP_REFERENCE_JNI_GLOBAL",

   "JVMTI_HEAP_REFERENCE_SYSTEM_CLASS",

   "JVMTI_HEAP_REFERENCE_MONITOR",

   "JVMTI_HEAP_REFERENCE_STACK_LOCAL",

   "JVMTI_HEAP_REFERENCE_JNI_LOCAL",

   "JVMTI_HEAP_REFERENCE_THREAD",

   "JVMTI_HEAP_REFERENCE_OTHER"

};

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

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

static int get_reference_index(jvmtiHeapReferenceKind   reference_kind,

                               const jvmtiHeapReferenceInfo* reference_info)

{

    int referrer_index = 0;

    switch (reference_kind) {

        case JVMTI_HEAP_REFERENCE_CONSTANT_POOL:

            referrer_index = reference_info->constant_pool.index;

            break;

        case JVMTI_HEAP_REFERENCE_FIELD:

        case JVMTI_HEAP_REFERENCE_STATIC_FIELD:

            referrer_index = reference_info->field.index;

            break;

        case JVMTI_HEAP_REFERENCE_ARRAY_ELEMENT:

            referrer_index = reference_info->array.index;

            break;

        case JVMTI_HEAP_REFERENCE_STACK_LOCAL:

            referrer_index = reference_info->stack_local.slot;

            /* Fall through */

        case JVMTI_HEAP_REFERENCE_JNI_LOCAL:

            referrer_index |= reference_info->stack_local.depth << 16;

            break;

        default:

            // TODO: check that realy should be done w/ other jvmtiHeapReferenceKind

            break;

    }

    return referrer_index;

} /* get_reference_index */

/** Initialize objectDescList. */

static int initObjectDescList(jvmtiEnv*    jvmti,

                              int          chainLength,

                              int*         objectsCount,

                              ObjectDesc** objectDescList)

{

    /* root object + reachable and unreachable object chains */

    *objectsCount = 1 + 2 * chainLength;

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

    fflush(0);

        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 = CHAIN_CLASS_TAG;

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

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

        }

    }

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

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

    /* Object with tag=100 must be referenced 2 times */

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

     return NSK_TRUE;

} /* initObjectDescList */

/** Find and tag classes. */

static int getAndTagClasses(jvmtiEnv*    jvmti,

                            JNIEnv*      jni,

                            jclass*      debugeeClass,

                            jclass*      rootObjectClass,

                            jclass*      chainObjectClass)

{

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("\nFound debugee class: 0x%p\n  %s\n",

           (void*) *debugeeClass, DEBUGEE_CLASS_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*rootObjectClass =

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

        nsk_jvmti_setFailStatus();

    }

    printf("\nFound root object class: 0x%p, tag=%ld\n  %s\n",

           (void*) *rootObjectClass,(long) ROOT_CLASS_TAG,

           ROOT_OBJECT_CLASS_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*chainObjectClass =

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

        nsk_jvmti_setFailStatus();

    }

    printf("\nFound chain object class: 0x%p, tag=%ld\n  %s\n",

           (void*) *chainObjectClass, (long) CHAIN_CLASS_TAG,

           CHAIN_OBJECT_CLASS_NAME);

    fflush(0);

     return NSK_TRUE;

} /* getAndTagClasses */

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

static int getFieldsAndObjects(jvmtiEnv*  jvmti,

                             JNIEnv*     jni,

                             jclass      debugeeClass,

                             jclass      rootObjectClass,

                             jclass      chainObjectClass,

                             jobject*    rootObjectPtr,

                             jfieldID*   reachableChainField,

                             jfieldID*   unreachableChainField,

                             jfieldID*   nextField)

{

    jfieldID rootObjectField = NULL;

    if (!NSK_JNI_VERIFY(jni, (rootObjectField =

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("\nFound fieldID: 0x%p - \'%s\' static field in debugee class\n",

           (void*) rootObjectField, OBJECT_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*reachableChainField =

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("\nFound fieldID: 0x%p - \'%s\' field in root object class\n",

           (void*) reachableChainField, REACHABLE_CHAIN_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*unreachableChainField =

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("\nFound fieldID: 0x%p - \'%s\' field in root object class\n",

           (void*) unreachableChainField, UNREACHABLE_CHAIN_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*nextField =

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("\nFound fieldID: 0x%p - \'%s\' field in chain object class\n",

           (void*) nextField, NEXT_FIELD_NAME);

    fflush(0);

    if (!NSK_JNI_VERIFY(jni, (*rootObjectPtr =

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("\nFound root object: 0x%p\n", (void*) *rootObjectPtr);

    fflush(0);

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    printf("Created root object global ref: 0x%p\n", (void*)*rootObjectPtr);

    fflush(0);

     return NSK_TRUE;

} /* getFieldsAndObjects */

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

static int getAndTagChainObjects(

    jvmtiEnv*  jvmti,

    JNIEnv*    jni,

    jobject    currObj,

    jfieldID   refField,

    jfieldID   nextField,

    int        count,

    ObjectDesc objectDescList[],

    jlong      tag,

    int        reachable)

{

    jobject nextObj = NULL;

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

    if (count <= 0) {

        return NSK_TRUE;

    }

    count--;

    tag++;

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    objectDescList[count].tag = objTag;

    if (reachable) {

        objectDescList[count].exp_found++;

    }

        nsk_jvmti_setFailStatus();

    }

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

    fflush(0);

    /* To continue traversing objects in the chain */

    if (!getAndTagChainObjects(jvmti,

                               jni,

                               nextObj,

                               nextField,

                               nextField,

                               count,

                               objectDescList,

                               tag,

                               reachable)

    ) {

        return NSK_FALSE;

    }

    return NSK_TRUE;

} /* getAndTagChainObjects */

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

static int getAndTagTestedObjects(

    jvmtiEnv*    jvmti,

    JNIEnv*      jni,

    int          chainLength,

    int*         objectsCount,

    ObjectDesc** objectDescList,

    jobject*     rootObjectPtr)

{

    jclass   debugeeClass          = NULL;

    jclass   rootObjectClass       = NULL;

    jclass   chainObjectClass      = NULL;

    jfieldID reachableChainField   = NULL;

    jfieldID unreachableChainField = NULL;

    jfieldID nextField             = NULL;

    if (initObjectDescList(jvmti,

                           chainLength,

                           objectsCount,

                           objectDescList) == NSK_FALSE) {

        return NSK_FALSE;

    }

    if (getAndTagClasses(jvmti,

                         jni,

                         &debugeeClass,

                         &rootObjectClass,

                         &chainObjectClass) == NSK_FALSE) {

        return NSK_FALSE;

    }

    if (getFieldsAndObjects(jvmti,

                            jni,

                            debugeeClass,

                            rootObjectClass,

                            chainObjectClass,

                            rootObjectPtr,

                            &reachableChainField,

                            &unreachableChainField,

                            &nextField) == NSK_FALSE) {

        return NSK_FALSE;

    }

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

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

    ) {

        nsk_jvmti_setFailStatus();

    }

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

           (long) ROOT_OBJECT_TAG, (void*) *rootObjectPtr);

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

    fflush(0);

    if (!getAndTagChainObjects(jvmti,

                               jni,

                               *rootObjectPtr,

                               reachableChainField,

                               nextField,

                               chainLength,

                               (*objectDescList) + 1,

                               CHAIN_OBJECT_TAG,

                               NSK_TRUE)  /* reachable objects */

    ) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

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

    if (!getAndTagChainObjects(jvmti,

                               jni,

                               *rootObjectPtr,

                               unreachableChainField,

                               nextField,

                               chainLength,

                               (*objectDescList) + 1 + chainLength,

                               CHAIN_OBJECT_TAG,

                               NSK_FALSE) /* unreachable objects */

    ) {

        nsk_jvmti_setFailStatus();

        return NSK_FALSE;

    }

    return NSK_TRUE;

} /* getAndTagTestedObjects */

/** 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) {

            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) {

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

            nsk_jvmti_setFailStatus();

        }

        fflush(0);

    }

    return NSK_TRUE;

} /* checkTestedObjects */

/** 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);

    }

    if (objectDescList != NULL) {

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

            nsk_jvmti_setFailStatus();

        }

    }

    fflush(0);