/*

 * Copyright (c) 1998, 2007, 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 "incls/_precompiled.incl"

#include "incls/_vtune_windows.cpp.incl"

static int current_method_ID = 0;

// ------------- iJITProf.h -------------------

// defined by Intel -- do not change

#include "windows.h"

extern "C" {

  enum iJITP_Event {

    ExceptionOccurred_S,                  // Java exception

    ExceptionOccurred_IDS,

    Shutdown,                             // VM exit

    ThreadCreate,                         // threads

    ThreadDestroy,

    ThreadSwitch,

    ClassLoadStart,                       // class loading

    ClassLoadEnd,

    GCStart,                              // GC

    GCEnd,

    NMethodCreate = 13,                   // nmethod creation

    NMethodDelete

    // rest of event types omitted (call profiling not supported yet)

  };

  // version number -- 0 if VTune not installed

  int WINAPI iJitP_VersionNumber();

  enum iJITP_ModeFlags {

    NoNotification = 0x0,                // don't call vtune

    NotifyNMethodCreate   = 0x1,         // notify NMethod_Create

    NotifyNMethodDelete   = 0x2,         // notify NMethod_Create

    NotifyMethodEnter     = 0x4,         // method entry

    NotifyMethodExit      = 0x8,         // method exit

    NotifyShutdown        = 0x10,        // VM exit

    NotifyGC              = 0x20,        // GC

  };

  // call back function type

  typedef void (WINAPI *ModeChangedFn)(iJITP_ModeFlags flags);

  // -------------  VTune method interfaces ----------------------

  typedef void  (WINAPI *RegisterCallbackFn)(ModeChangedFn fn);   // register callback

  typedef int   (WINAPI *NotifyEventFn)(iJITP_Event, void* event_data);

  // specific event data structures

  // data for NMethodCreate

  struct VTuneObj {                       // base class for allocation

                                          // (can't use CHeapObj -- has vtable ptr)

    void* operator new(size_t size) { return os::malloc(size); }

    void  operator delete(void* p)  { fatal("never delete VTune data"); }

  };

  struct LineNumberInfo : VTuneObj {      // PC-to-line number mapping

    unsigned long offset;                 // byte offset from start of method

    unsigned long line_num;               // corresponding line number

  };

  struct MethodLoadInfo : VTuneObj {

    unsigned long methodID;               // unique method ID

    const char* name;                     // method name

    unsigned long instr_start;            // start address

    unsigned long instr_size;             // length in bytes

    unsigned long line_number_size;       // size of line number table

    LineNumberInfo* line_number_table;    // line number mapping

    unsigned long classID;                // unique class ID

    char* class_file_name;                // fully qualified class file name

    char* source_file_name;               // fully qualified source file name

    MethodLoadInfo(nmethod* nm);          // for real nmethods

    MethodLoadInfo(const char* vm_name, address start, address end);

                                          // for "nmethods" like stubs, interpreter, etc

  };

  // data for NMethodDelete

  struct MethodInfo : VTuneObj {

    unsigned long methodID;               // unique method ID

    unsigned long classID;                // (added for convenience -- not part of Intel interface)

    MethodInfo(methodOop m);

  };

};

MethodInfo::MethodInfo(methodOop m) {

  // just give it a new ID -- we're not compiling methods twice (usually)

  // (and even if we did, one might want to see the two versions separately)

  methodID = ++current_method_ID;

}

MethodLoadInfo::MethodLoadInfo(const char* vm_name, address start, address end) {

  classID  = 0;

  methodID = ++current_method_ID;

  name = vm_name;

  instr_start = (unsigned long)start;

  instr_size = end - start;

  line_number_size = 0;

  line_number_table = NULL;

  class_file_name = source_file_name = "HotSpot JVM";

}

MethodLoadInfo::MethodLoadInfo(nmethod* nm) {

  methodOop m = nm->method();

  MethodInfo info(m);

  classID  = info.classID;

  methodID = info.methodID;

  name = strdup(m->name()->as_C_string());

  instr_start = (unsigned long)nm->instructions_begin();

  instr_size = nm->code_size();

  line_number_size = 0;

  line_number_table = NULL;

  klassOop kl = m->method_holder();

  char* class_name = Klass::cast(kl)->name()->as_C_string();

  char* file_name = NEW_C_HEAP_ARRAY(char, strlen(class_name) + 1);

  strcpy(file_name, class_name);

  class_file_name = file_name;

  char* src_name = NEW_C_HEAP_ARRAY(char, strlen(class_name) + strlen(".java") + 1);

  strcpy(src_name, class_name);

  strcat(src_name, ".java");

  source_file_name = src_name;

}

// --------------------- DLL loading functions ------------------------

#define DLLNAME "iJitProf.dll"

static HINSTANCE load_lib(char* name) {

  HINSTANCE lib = NULL;

  HKEY hk;

  // try to get VTune directory from the registry

  if (RegOpenKey(HKEY_CURRENT_USER, "Software\\VB and VBA Program Settings\\VTune\\StartUp", &hk) == ERROR_SUCCESS) {

    for (int i = 0; true; i++) {

      char szName[MAX_PATH + 1];

      char szVal [MAX_PATH + 1];

      DWORD cbName, cbVal;

      cbName = cbVal = MAX_PATH + 1;

      if (RegEnumValue(hk, i, szName, &cbName, NULL, NULL, (LPBYTE)szVal, &cbVal) == ERROR_SUCCESS) {

        // get VTune directory

        if (!strcmp(szName, name)) {

          char*p = szVal;

          while (*p == ' ') p++;    // trim

          char* q = p + strlen(p) - 1;

          while (*q == ' ') *(q--) = '\0';

          // chdir to the VTune dir

          GetCurrentDirectory(MAX_PATH + 1, szName);

          SetCurrentDirectory(p);

          // load lib

          lib = LoadLibrary(strcat(strcat(p, "\\"), DLLNAME));

          if (lib != NULL && WizardMode) tty->print_cr("*loaded VTune DLL %s", p);

          // restore current dir

          SetCurrentDirectory(szName);

          break;

        }

      } else {

        break;

      }

    }

  }

  return lib;

}

static RegisterCallbackFn iJIT_RegisterCallback = NULL;

static NotifyEventFn      iJIT_NotifyEvent      = NULL;

static bool load_iJIT_funcs() {

  // first try to load from PATH

  HINSTANCE lib = LoadLibrary(DLLNAME);

  if (lib != NULL && WizardMode) tty->print_cr("*loaded VTune DLL %s via PATH", DLLNAME);

  // if not successful, try to look in the VTUNE directory

  if (lib == NULL) lib = load_lib("VTUNEDIR30");

  if (lib == NULL) lib = load_lib("VTUNEDIR25");

  if (lib == NULL) lib = load_lib("VTUNEDIR");

  if (lib == NULL) return false;    // unsuccessful

  // try to load the functions

  iJIT_RegisterCallback = (RegisterCallbackFn)GetProcAddress(lib, "iJIT_RegisterCallback");

  iJIT_NotifyEvent      = (NotifyEventFn)     GetProcAddress(lib, "iJIT_NotifyEvent");

  if (!iJIT_RegisterCallback) tty->print_cr("*couldn't find VTune entry point iJIT_RegisterCallback");

  if (!iJIT_NotifyEvent)      tty->print_cr("*couldn't find VTune entry point iJIT_NotifyEvent");

  return iJIT_RegisterCallback != NULL && iJIT_NotifyEvent != NULL;

}

// --------------------- VTune class ------------------------

static bool active = false;

static int  flags  = 0;

void VTune::start_GC() {

  if (active && (flags & NotifyGC)) iJIT_NotifyEvent(GCStart, NULL);

}

void VTune::end_GC() {

  if (active && (flags & NotifyGC)) iJIT_NotifyEvent(GCEnd, NULL);

}

void VTune::start_class_load() {

  // not yet implemented in VTune

}

void VTune::end_class_load() {

  // not yet implemented in VTune

}

void VTune::exit() {

  if (active && (flags & NotifyShutdown)) iJIT_NotifyEvent(Shutdown, NULL);

}

void VTune::register_stub(const char* name, address start, address end) {

  if (flags & NotifyNMethodCreate) {

    MethodLoadInfo* info = new MethodLoadInfo(name, start, end);

    if (PrintMiscellaneous && WizardMode && Verbose) {

      tty->print_cr("NMethodCreate %s (%d): %#x..%#x", info->name, info->methodID,

                    info->instr_start, info->instr_start + info->instr_size);

    }

    iJIT_NotifyEvent(NMethodCreate, info);

  }

}

void VTune::create_nmethod(nmethod* nm) {

  if (flags & NotifyNMethodCreate) {

    MethodLoadInfo* info = new MethodLoadInfo(nm);

    if (PrintMiscellaneous && WizardMode && Verbose) {

      tty->print_cr("NMethodCreate %s (%d): %#x..%#x", info->name, info->methodID,

                    info->instr_start, info->instr_start + info->instr_size);

    }

    iJIT_NotifyEvent(NMethodCreate, info);

  }

}

void VTune::delete_nmethod(nmethod* nm) {

  if (flags & NotifyNMethodDelete) {

    MethodInfo* info = new MethodInfo(nm->method());

    iJIT_NotifyEvent(NMethodDelete, info);

  }

}

static void set_flags(int new_flags) {

  flags = new_flags;

  // if (WizardMode) tty->print_cr("*new VTune flags: %#x", flags);

}

void vtune_init() {

  if (!UseVTune) return;

  active = load_iJIT_funcs();

  if (active) {

    iJIT_RegisterCallback((ModeChangedFn)set_flags);

  } else {

    assert(flags == 0, "flags shouldn't be set");

  }

}