<?xml version="1.0"?> 

<!--

 Copyright (c) 2002, 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.

-->

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">

<xsl:import href="jvmtiLib.xsl"/>

<xsl:output method="text" indent="no" omit-xml-declaration="yes"/>

<xsl:param name="trace"></xsl:param>

<xsl:param name="interface"></xsl:param>

<xsl:template match="specification">

  <xsl:call-template name="sourceHeader"/>

  <xsl:text>

# include "precompiled.hpp"

# include "memory/resourceArea.hpp"

# include "utilities/macros.hpp"

#if INCLUDE_JVMTI

# include "logging/log.hpp"

# include "oops/oop.inline.hpp"

# include "prims/jvmtiEnter.inline.hpp"

# include "prims/jvmtiRawMonitor.hpp"

# include "prims/jvmtiUtil.hpp"

# include "runtime/threadSMR.hpp"

</xsl:text>

  <xsl:if test="$trace = 'Trace'">

   <xsl:text>

#ifdef JVMTI_TRACE

</xsl:text>

  </xsl:if>

 <xsl:if test="$trace != 'Trace'">

    <xsl:text>

// Error names

const char* JvmtiUtil::_error_names[] = {

</xsl:text>

    <xsl:call-template name="fillEntityName"> 

      <xsl:with-param name="entities" select="errorsection/errorcategory/errorid"/>

    </xsl:call-template>

    <xsl:text>

};

// Event threaded

const bool JvmtiUtil::_event_threaded[] = {

</xsl:text>

    <xsl:call-template name="fillEventThreaded"> 

      <xsl:with-param name="entities" select="eventsection/event"/>

    </xsl:call-template>

    <xsl:text>

};

</xsl:text>

    <xsl:call-template name="eventCapabilitiesTest"/>

 </xsl:if>

 <xsl:if test="$trace = 'Trace'">

<!--  all this just to return the highest event number -->

  <xsl:variable name="maxEvent">

    <xsl:for-each select="eventsection/event">

      <xsl:variable name="mynum" select="@num"/>

      <xsl:if test="count(../../eventsection/event[@num &gt; $mynum]) = 0">

        <xsl:value-of select="@num"/>

      </xsl:if>

    </xsl:for-each>    

  </xsl:variable>

  <xsl:text>jbyte JvmtiTrace::_event_trace_flags[</xsl:text>

  <xsl:value-of select="1+$maxEvent"/>

  <xsl:text>];

jint JvmtiTrace::_max_event_index = </xsl:text>

  <xsl:value-of select="$maxEvent"/>

  <xsl:text>;

// Event names

const char* JvmtiTrace::_event_names[] = {

</xsl:text>

    <xsl:call-template name="fillEntityName"> 

      <xsl:with-param name="entities" select="eventsection/event"/>

    </xsl:call-template>

    <xsl:text>

};

</xsl:text>

    <xsl:apply-templates select="//constants[@kind='enum']"/>

  </xsl:if>

  <xsl:apply-templates select="functionsection"/>

  <xsl:if test="$trace='Trace'">

   <xsl:text>

#endif /*JVMTI_TRACE */

</xsl:text>

  </xsl:if>

</xsl:template>

<xsl:template match="constants">

  <xsl:text>

// </xsl:text>

  <xsl:value-of select="@label"/>

  <xsl:text> names

const char* </xsl:text>

  <xsl:value-of select="@id"/>

  <xsl:text>ConstantNames[] = {

</xsl:text>

  <xsl:apply-templates select="constant" mode="constname"/>

  <xsl:text>  NULL

};

// </xsl:text>

  <xsl:value-of select="@label"/>

  <xsl:text> value

jint </xsl:text>

  <xsl:value-of select="@id"/>

  <xsl:text>ConstantValues[] = {

</xsl:text>

  <xsl:apply-templates select="constant" mode="constvalue"/>

  <xsl:text>  0

};

</xsl:text>

</xsl:template>

<xsl:template match="constant" mode="constname">

  <xsl:text>  "</xsl:text>

  <xsl:value-of select="@id"/>

  <xsl:text>",

</xsl:text>

</xsl:template>

<xsl:template match="constant" mode="constvalue">

  <xsl:text>  </xsl:text>

  <xsl:value-of select="@num"/>

  <xsl:text>,

</xsl:text>

</xsl:template>

<xsl:template name="eventCapabilitiesTest">

  <xsl:text>

// Check Event Capabilities

const bool JvmtiUtil::has_event_capability(jvmtiEvent event_type, const jvmtiCapabilities* capabilities_ptr) {

  switch (event_type) {

</xsl:text>

  <xsl:for-each select="//eventsection/event">

    <xsl:variable name="capa" select="capabilities/required"/>

    <xsl:if test="count($capa)">

        <xsl:text>    case </xsl:text>

        <xsl:value-of select="@const"/>

        <xsl:text>:

      return capabilities_ptr-&gt;</xsl:text>

        <xsl:value-of select="$capa/@id"/>

        <xsl:text> != 0;

</xsl:text>

    </xsl:if>

  </xsl:for-each>

  <xsl:text>  default: break; }

  // if it does not have a capability it is required

  return JNI_TRUE;

}

</xsl:text>

</xsl:template>

<xsl:template match="functionsection">

  <xsl:if test="$trace='Trace'">

<!--  all this just to return the highest function number -->

  <xsl:variable name="maxFunction">

    <xsl:for-each select="category/function">

      <xsl:variable name="mynum" select="@num"/>

      <xsl:if test="count(../../category/function[@num &gt; $mynum]) = 0">

        <xsl:value-of select="@num"/>

      </xsl:if>

    </xsl:for-each>    

  </xsl:variable>

  <xsl:text>jbyte JvmtiTrace::_trace_flags[</xsl:text>

  <xsl:value-of select="1+$maxFunction"/>

  <xsl:text>];

jint JvmtiTrace::_max_function_index = </xsl:text>

  <xsl:value-of select="$maxFunction"/>

  <xsl:text>;

// Function names

const char* JvmtiTrace::_function_names[] = {

</xsl:text>

  <xsl:call-template name="fillEntityName">

    <xsl:with-param name="entities" select="category/function"/>

  </xsl:call-template>

  <xsl:text>

};

// Exclude list

short JvmtiTrace::_exclude_functions[] = {

  </xsl:text>

  <xsl:apply-templates select="category/function" mode="notrace">

    <xsl:sort select="@num"/>

  </xsl:apply-templates>

  <xsl:text>0

};

</xsl:text>

  </xsl:if>

  <xsl:text>

extern "C" {

</xsl:text>

  <xsl:apply-templates select="category" mode="wrapper"/>

  <xsl:text>

} /* end extern "C" */

// JVMTI API functions

struct jvmtiInterface_1_ jvmti</xsl:text>

  <xsl:value-of select="$trace"/>

  <xsl:text>_Interface = {

</xsl:text>

  <xsl:call-template name="fillFuncStruct">

    <xsl:with-param name="funcs" select="category/function[count(@hide)=0]"/>

  </xsl:call-template>

  <xsl:text>

};

#endif // INCLUDE_JVMTI

</xsl:text>

</xsl:template>

<xsl:template match="function" mode="functionid">

  <xsl:text>jvmti</xsl:text>

  <xsl:value-of select="$trace"/>

  <xsl:text>_</xsl:text>

  <xsl:value-of select="@id"/>

</xsl:template>

<xsl:template name="fillFuncStructDoit">

  <xsl:param name="func"/>

  <xsl:param name="index"/>

  <xsl:text>                              /* </xsl:text>

  <xsl:number value="$index" format="  1"/>

  <xsl:text> : </xsl:text>

  <xsl:choose>

    <xsl:when test="count($func)=1">

      <xsl:value-of select="$func/synopsis"/>

      <xsl:text> */

      </xsl:text>

      <xsl:apply-templates select="$func" mode="functionid"/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:text> RESERVED */

      NULL</xsl:text>        

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<!-- generic function iterator applied to the function structure -->

<xsl:template name="fillFuncStruct">

  <xsl:param name="funcs"/>

  <xsl:param name="index" select="1"/>

  <xsl:call-template name="fillFuncStructDoit">

    <xsl:with-param name="func" select="$funcs[@num=$index]"/>

    <xsl:with-param name="index" select="$index"/>

  </xsl:call-template>

  <xsl:if test="count($funcs[@num &gt; $index]) &gt; 0">

    <xsl:text>,

</xsl:text>

    <xsl:call-template name="fillFuncStruct">

      <xsl:with-param name="funcs" select="$funcs"/>

      <xsl:with-param name="index" select="1+$index"/>

    </xsl:call-template>

  </xsl:if>

</xsl:template>

<xsl:template name="fillEntityNameDoit">

  <xsl:param name="entity"/>

  <xsl:param name="index"/>

  <xsl:choose>

    <xsl:when test="count($entity) &gt; 0">

      <xsl:text>  "</xsl:text>

      <xsl:value-of select="$entity[position()=1]/@id"/>

      <xsl:text>"</xsl:text>

    </xsl:when>

    <xsl:otherwise>

      <xsl:text>  NULL</xsl:text>        

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<!-- generic entity (with id and num) iterator applied to entity names -->

<xsl:template name="fillEntityName">

  <xsl:param name="entities"/>

  <xsl:param name="index" select="0"/>

  <xsl:call-template name="fillEntityNameDoit">

    <xsl:with-param name="entity" select="$entities[@num=$index]"/>

    <xsl:with-param name="index" select="$index"/>

  </xsl:call-template>

  <xsl:if test="count($entities[@num &gt; $index]) &gt; 0">

    <xsl:text>,

</xsl:text>

    <xsl:call-template name="fillEntityName">

      <xsl:with-param name="entities" select="$entities"/>

      <xsl:with-param name="index" select="1+$index"/>

    </xsl:call-template>

  </xsl:if>

</xsl:template>

<xsl:template name="fillEventThreadedDoit">

  <xsl:param name="entity"/>

  <xsl:param name="index"/>

  <xsl:choose>

    <xsl:when test="count($entity) &gt; 0">

      <xsl:choose>

        <xsl:when test="count($entity[position()=1]/@filtered)=0">

          <xsl:text>  false</xsl:text>

        </xsl:when>

        <xsl:otherwise>

          <xsl:text>  true</xsl:text>        

        </xsl:otherwise>

      </xsl:choose>

    </xsl:when>

    <xsl:otherwise>

      <xsl:text>  false</xsl:text>        

    </xsl:otherwise>

  </xsl:choose>

</xsl:template>

<xsl:template name="fillEventThreaded">

  <xsl:param name="entities"/>

  <xsl:param name="index" select="0"/>

  <xsl:call-template name="fillEventThreadedDoit">

    <xsl:with-param name="entity" select="$entities[@num=$index]"/>

    <xsl:with-param name="index" select="$index"/>

  </xsl:call-template>

  <xsl:if test="count($entities[@num &gt; $index]) &gt; 0">

    <xsl:text>,

</xsl:text>

    <xsl:call-template name="fillEventThreaded">

      <xsl:with-param name="entities" select="$entities"/>

      <xsl:with-param name="index" select="1+$index"/>

    </xsl:call-template>

  </xsl:if>

</xsl:template>

<xsl:template match="function" mode="notrace">

  <xsl:if test="count(@impl)=1 and contains(@impl,'notrace')">

    <xsl:value-of select="@num"/>

    <xsl:text>,

  </xsl:text>

  </xsl:if>

</xsl:template>

<xsl:template match="category" mode="wrapper">

  <xsl:text>

  //

  // </xsl:text><xsl:value-of select="@label"/><xsl:text> functions

  // 

</xsl:text>

  <xsl:apply-templates select="function[count(@hide)=0]"/>

</xsl:template>

<xsl:template match="function" mode="transition">

  <xsl:param name="space">

    <xsl:text>

  </xsl:text>

  </xsl:param>

  <xsl:value-of select="$space"/>

  <xsl:choose> 

    <xsl:when test="count(@callbacksafe)=0 or not(contains(@callbacksafe,'safe'))">

      <xsl:text>if (this_thread == NULL || !this_thread->is_Java_thread()) {</xsl:text> 

    </xsl:when> 

    <xsl:otherwise> 

      <xsl:choose>

        <xsl:when test="count(@phase)=0 or contains(@phase,'live') or contains(@phase,'start')">

	  <xsl:text>if (this_thread == NULL || (!this_thread->is_Java_thread() &amp;&amp; !this_thread->is_VM_thread())) {</xsl:text>

        </xsl:when>

        <xsl:otherwise>

          <xsl:text>if (!this_thread->is_Java_thread()) {</xsl:text> 

        </xsl:otherwise>

      </xsl:choose>

     </xsl:otherwise> 

  </xsl:choose> 

  <xsl:if test="$trace='Trace'">

    <xsl:value-of select="$space"/>

    <xsl:text>  if (trace_flags) {</xsl:text>

    <xsl:value-of select="$space"/>

    <xsl:text>    log_trace(jvmti)("[non-attached thread] %s %s",  func_name,</xsl:text>

    <xsl:value-of select="$space"/>

    <xsl:text>    JvmtiUtil::error_name(JVMTI_ERROR_UNATTACHED_THREAD));</xsl:text>

    <xsl:value-of select="$space"/>

    <xsl:text>  }</xsl:text>

  </xsl:if>

  <xsl:value-of select="$space"/>

  <xsl:text>  return JVMTI_ERROR_UNATTACHED_THREAD;</xsl:text>

  <xsl:value-of select="$space"/>

  <xsl:text>}</xsl:text>  

  <xsl:value-of select="$space"/>  

  <xsl:if test="count(@impl)=0 or not(contains(@impl,'innative'))">

    <xsl:text>JavaThread* current_thread = (JavaThread*)this_thread;</xsl:text>   

    <xsl:value-of select="$space"/>

    <xsl:text>ThreadInVMfromNative __tiv(current_thread);</xsl:text>

    <xsl:value-of select="$space"/>

    <xsl:text>VM_ENTRY_BASE(jvmtiError, </xsl:text>

    <xsl:apply-templates select="." mode="functionid"/>

    <xsl:text> , current_thread)</xsl:text>

    <xsl:value-of select="$space"/>

    <xsl:text>debug_only(VMNativeEntryWrapper __vew;)</xsl:text>

    <xsl:if test="count(@callbacksafe)=0 or not(contains(@callbacksafe,'safe'))">

      <xsl:value-of select="$space"/>

      <xsl:text>CautiouslyPreserveExceptionMark __em(this_thread);</xsl:text>

    </xsl:if>

  </xsl:if>

</xsl:template>

<xsl:template match="required">

  <xsl:text>

  if (jvmti_env-&gt;get_capabilities()-&gt;</xsl:text>

    <xsl:value-of select="@id"/>

    <xsl:text> == 0) {

</xsl:text>

    <xsl:if test="$trace='Trace'">

      <xsl:text>    if (trace_flags) {

          log_trace(jvmti)("[%s] %s %s",  curr_thread_name, func_name, 

                    JvmtiUtil::error_name(JVMTI_ERROR_MUST_POSSESS_CAPABILITY));

    }

</xsl:text>

    </xsl:if>

    <xsl:text>    return JVMTI_ERROR_MUST_POSSESS_CAPABILITY;

  }

</xsl:text>

</xsl:template>

<xsl:template match="function">

  <xsl:text>

static jvmtiError JNICALL

</xsl:text>

  <xsl:apply-templates select="." mode="functionid"/>

  <xsl:text>(jvmtiEnv* env</xsl:text>

  <xsl:apply-templates select="parameters" mode="signature"/>

  <xsl:text>) {

</xsl:text>

  <xsl:if test="not(contains(@jkernel,'yes'))">

  <xsl:text>&#xA;#if !INCLUDE_JVMTI &#xA;</xsl:text>

  <xsl:text>  return JVMTI_ERROR_NOT_AVAILABLE; &#xA;</xsl:text>

  <xsl:text>#else &#xA;</xsl:text>

  </xsl:if>

  <xsl:apply-templates select="." mode="traceSetUp"/>

  <xsl:choose>

    <xsl:when test="count(@phase)=0 or contains(@phase,'live')">

      <xsl:text>  if(!JvmtiEnv::is_vm_live()) {

</xsl:text>

    <xsl:if test="$trace='Trace'">

      <xsl:text>    if (trace_flags) {

          log_trace(jvmti)("[-] %s %s(%d)", func_name,

                    JvmtiUtil::error_name(JVMTI_ERROR_WRONG_PHASE), JvmtiEnv::get_phase());

    }

</xsl:text>

    </xsl:if>

    <xsl:text>    return JVMTI_ERROR_WRONG_PHASE;

  }</xsl:text>  

      <xsl:text>  

  Thread* this_thread = Thread::current_or_null(); </xsl:text>

      <xsl:apply-templates select="." mode="transition"/>

    </xsl:when>

    <xsl:otherwise>

      <xsl:if test="contains(@phase,'onload')">

        <xsl:text>  if(JvmtiEnv::get_phase()!=JVMTI_PHASE_ONLOAD</xsl:text>

        <xsl:if test="not(contains(@phase,'onloadOnly'))">

          <xsl:text> &amp;&amp; JvmtiEnv::get_phase()!=JVMTI_PHASE_LIVE</xsl:text>

        </xsl:if>

        <xsl:text>) {

</xsl:text>

    <xsl:if test="$trace='Trace'">

      <xsl:text>    if (trace_flags) {

          log_trace(jvmti)("[-] %s %s",  func_name, 

                    JvmtiUtil::error_name(JVMTI_ERROR_WRONG_PHASE));

    }

</xsl:text>

    </xsl:if>

    <xsl:text>    return JVMTI_ERROR_WRONG_PHASE;

  }</xsl:text>

      </xsl:if>

      <xsl:if test="contains(@phase,'start')">

        <xsl:text>  if(JvmtiEnv::get_phase(env)!=JVMTI_PHASE_START &amp;&amp; JvmtiEnv::get_phase()!=JVMTI_PHASE_LIVE) {