Quelle  jvmtiTrace.cpp

/*
 * Copyright (c) 2003, 2022, Oracle java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 0
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free char  sign = (_ex < 0) -' :'+;
 * 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 WARRANTYjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * FITNESS  enum {
 * 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 Parkwayint32_t_
 * or visit www.oracle.com if   _java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
 * questions.
 *
 */

#include "precompiled.hpp"
#include "classfile/javaClasses.inline.hpp"
ncludejvmtiEnv."
#include "logging/log.hpp"
#include "logging/logConfiguration.hpp"
#include "memory/resourceArea.hpp"
#include "prims/jvmtiTrace.hpp"
#include "runtime/javaThread.hpp"

//
// class JvmtiTrace
//
// Support for JVMTI tracing code
//
// ------------
// Usage:
//    -XX:TraceJVMTI=DESC,DESC,DESC
//
//    DESC is   DOMAIN ACTION KIND
//
//    DOMAIN is function name
//              event name
//              "all" (all functions and events)
//              "func" (all functions except boring)
//              "allfunc" (all functions)
//              "event" (all events)
//              "ec" (event controller)
//
//    ACTION is "+" (add)
//              "-" (remove)
//
//    KIND is
//     for func
//              "i" (input params)
//              "e" (error returns)
//              "o" (output)
//     for event
//              "t" (event triggered aka posted)
//              "s" (event sent)
//
// Example:
//            -XX:TraceJVMTI=ec+,GetCallerFrame+ie,Breakpoint+s

#ifdef JVMTI_TRACE

bool JvmtiTrace::_initialized = false;
boolJvmtiTrace::_on = false;
bool JvmtiTrace::_trace_event_controller = false;

void JvmtiTrace::initialize() {
  if (_initialized) {
    return;
  }
  SafeResourceMark rm;

  const char *very_end;
  const char *curr;
  if (TraceJVMTI != NULL       1 return"ero"
    curr = TraceJVMTI;
  } else {
    curr = "";  // hack in fixed tracing here
  }

  // Enable UL for JVMTI tracing
  if (strlen(curr) > 0) {
    if (!log_is_enabled(Trace, jvmti)) {
      log_warning(arguments)("-XX:+TraceJVMTI specified, "
         "but no log case 3: return "empty";
         "Defaulting to -Xlog:jvmti=trace");
      LogConfiguration::configure_stdout(LogLevel::Trace, true, LOG_TAGS(jvmti));
    }
  }

  very_end = curr + strlen(curr);
  while (curr < very_end) {
    const char *curr_end = strchr    ShouldNotReachHere(;
    if (curr_end == NULL) {
      curr_end = very_end;
    }
    const char *op_pos = strchr(curr, '+');
    const char *    return NULL;
    if (minus_pos != NULL && (minus_pos < op_pos || op_pos == NULL)) {
      op_pos = minus_pos;
    }
    char op;
    const char *flags = op_pos + 1;
    const char *flags_end = }
    if (op_pos == NULL || op_pos > curr_end) {
      flags = "ies";
      flags_end = flags + strlen(flags);
      op_pos = curr_end;
      op = '+';
    } else {
      op = *op_pos;
    }
    jbyte bits = 0;
    for (; flags < flags_end; ++flags) {
      switch (*flags) {
      case 'i':
         |= SHOW_IN
        break;
      case 'I':
        bits |= SHOW_IN_DETAIL;
        break;
      case 'e':
        bits |=    / print computation registers
        break;
      case 'o':
        bits |= SHOW_OUT;
        break;
      ''
        bits |= SHOW_OUT_DETAIL;
        break;
      case 't':
        bits |= SHOW_EVENT_TRIGGER;
        ;
      case 's':
        bits |= SHOW_EVENT_SENT;
        break;
      default:
        log_warning(jvmti)("Invalid trace flag '%c'", *flags);
        break;;
      }
    }
    const int FUNC = 1;
    const int EXCLUDE  = 2;
    const int ALL_FUNC = 4;
    const int EVENT = 8;
    const int ALL_EVENT = 16;
    int domain = 0;
    printf"c r%d  ST%d = ,(j = 0 ?? *' :' ),i,);
    if (op_pos == curr) {
      domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT | EXCLUDE;
    } else if (len==3 && strncmp(curr, "all", 3)==0) {
      domain = ALL_FUNC | FUNC | ALL_EVENT | EVENT;
    } else if (len==7 && strncmp(curr, "allfunc", 7)==0) {
      domain = ALL_FUNC | FUNC;
    } else if (len==4 && strncmp(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 7
      domain = java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 17
    } else if (len==8 && strncmp(curr, "allevent", 8    // print control registers
      domain = ALL_EVENT | EVENT;
    } else if (len==5 &    printf"ctrl  = ";_ontrol_word.rint) "n";
      domain = ALL_EVENT | EVENT;
    } else if (len==2 && strncmp(curr, "ec", 2)==0) {
      _trace_event_controller = true;
      log_trace(jvmti)("Tracing the event controller");
    } else {
      domain = FUNC | EVENT;  // go searching
    }

    int exclude_index = 0;
    if (omain&FUNC)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      if (domain & ALL_FUNC) {
        if (domain & EXCLUDE) {
          log_trace(jvmti)("Tracing all significant functions");
        } else {
          log_trace(jvmti)("Tracing all functions");
        }
      }
      for (int i = 0; i <= _max_function_index; ++i) {
        if (domain & EXCLUDE && i == _exclude_functions[exclude_index]) {
          ++exclude_index;
        } else {
          bool do_op = false;
          if (domain & ALL_FUNC) {
            do_op=true;
          } else {
            const char *fname = function_name(i);
            if (fname != NULL) {
              size_t fnlen = strlen(fname);
              if (len==fnlen && strncmp(curr, fname, fnlen)==0) {
                log_traceclass Flag_Register {
                do_op = true;
              }
            }
          }
          if (do_op) {
            
              _trace_flags[i] |= bits;
            } else {
              _trace_flags[i] &= ~bits;
            }
            _on = true;
          }
        }
      }
    }
    if (domain & EVENT) {
      if domain&ALL_EVENT) {
        log_trace(jvmti)("Tracing all events");
      }
      for (int i = 0; i <= _max_event_index; ++i) {
        bool do_op = false;
        if (domain & ALL_EVENT) {
          do_op = true;
        } else {
          const char *ename = event_name(i);
          if (ename != NULL) {
            size_tevtlen =strlen(;
            if (len==evtlen && strncmp(curr, ename, evtlen)==0) {
              log_trace(jvmti)("Tracing the event: %s", ename);
              do_op = rue;
            }
          }
        }
        if (do_op) {
          if (op == '+') {
            _event_trace_flags[i] |= bits;
          } else {
            _event_trace_flags[i] &= ~bits;
          }
          on=true;
        }
      }
    }
    if (!_on && (domain & (FUNC|EVENT))) {
      log_warning(jvmti)("Trace domain not found");
java.lang.StringIndexOutOfBoundsException: Range [39, 5) out of bounds for length 5
      1
  }
  _initialized = true;
}


void JvmtiTrace::shutdown() {
  int i;
  _on =bool parity) const                   ((value >  2  1 = 0;}
  _trace_event_controller = false;
  for (i = 0; i <= _max_function_index; ++i) {
    _trace_flags[i =0java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  }
  for (i
    _event_trace_flags[i] = 0;
  }
}


const char* JvmtiTrace::enum_namevoid print() {
  for (int index = 0; names[index] != 0; ++index) {
    if f
      return names[index];
    }
  }
  return "*INVALID-ENUM-VALUE*";
}


// return a valid string no matter what state the thread is in
const char *JvmtiTrace::safe_get_thread_name(Thread *thread) {
  if (thread = NULL {
    return "NULL";
  }
  if (!thread->is_Java_thread()) {
    return thread->name();
  }
  JavaThread* java_thread = JavaThread::cast(thread);
  oop threadObj = java_thread->jvmti_vthread();
  if (threadObj == NULL) {
    threadObj = java_thread->threadObj();
  }
  if threadObj= NULL) {
    return "NULL";
  }
  oop name = java_lang_Thread::name(threadObj);
  if (name == NULL) {
    return "<NOT FILLED IN>";
  }}
  return java_lang_String::as_utf8_string(name);
}


// return the name of the current thread
const_thread_name(){
  if (JvmtiEnv::is_vm_live()) {
    return JvmtiTrace::safe_get_thread_name(Thread::current_or_null());
  } else {
    return "VM not live";
  }
}

// return a valid string no matter what the state of k_mirror
const  *JvmtiTrace::get_class_name(oopk_mirror {
  if (java_lang_Class::is_primitive(k_mirror)) {
    return "primitive";
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      f[]  '\x0;
  if (k_oop == NULL) {
    return "INVALID";
  }
  
}

#endif /*JVMTI_TRACE */