/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp

Bug Summary

File:	jdk/src/hotspot/share/utilities/globalDefinitions.hpp
Warning:	line 1200, column 3 Undefined or garbage value returned to caller

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name method.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/libjvm/objs/precompiled -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D _GNU_SOURCE -D _REENTRANT -D LIBC=gnu -D LINUX -D VM_LITTLE_ENDIAN -D _LP64=1 -D ASSERT -D CHECK_UNHANDLED_OOPS -D TARGET_ARCH_x86 -D INCLUDE_SUFFIX_OS=_linux -D INCLUDE_SUFFIX_CPU=_x86 -D INCLUDE_SUFFIX_COMPILER=_gcc -D TARGET_COMPILER_gcc -D AMD64 -D HOTSPOT_LIB_ARCH="amd64" -D COMPILER1 -D COMPILER2 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -I /home/daniel/Projects/java/jdk/src/hotspot/share/precompiled -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjimage -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc/adfiles -I /home/daniel/Projects/java/jdk/src/hotspot/share -I /home/daniel/Projects/java/jdk/src/hotspot/os/linux -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix -I /home/daniel/Projects/java/jdk/src/hotspot/cpu/x86 -I /home/daniel/Projects/java/jdk/src/hotspot/os_cpu/linux_x86 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/hotspot/variant-server/gensrc -D _FORTIFY_SOURCE=2 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/x86_64-linux-gnu/c++/7.5.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.5.0/../../../../include/c++/7.5.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-format-zero-length -Wno-unused-parameter -Wno-unused -Wno-parentheses -Wno-comment -Wno-unknown-pragmas -Wno-address -Wno-delete-non-virtual-dtor -Wno-char-subscripts -Wno-array-bounds -Wno-int-in-bool-context -Wno-ignored-qualifiers -Wno-missing-field-initializers -Wno-implicit-fallthrough -Wno-empty-body -Wno-strict-overflow -Wno-sequence-point -Wno-maybe-uninitialized -Wno-misleading-indentation -Wno-cast-function-type -Wno-shift-negative-value -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make/hotspot -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fno-rtti -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c++ /home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp

/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp

→

1/*
* Copyright (c) 1997, 2021, 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.
*
*/

25#include "precompiled.hpp"
26#include "cds/cppVtables.hpp"
27#include "cds/metaspaceShared.hpp"
28#include "classfile/classLoaderDataGraph.hpp"
29#include "classfile/metadataOnStackMark.hpp"
30#include "classfile/symbolTable.hpp"
31#include "classfile/systemDictionary.hpp"
32#include "classfile/vmClasses.hpp"
33#include "code/codeCache.hpp"
34#include "code/debugInfoRec.hpp"
35#include "compiler/compilationPolicy.hpp"
36#include "gc/shared/collectedHeap.inline.hpp"
37#include "interpreter/bytecodeStream.hpp"
38#include "interpreter/bytecodeTracer.hpp"
39#include "interpreter/bytecodes.hpp"
40#include "interpreter/interpreter.hpp"
41#include "interpreter/oopMapCache.hpp"
42#include "logging/log.hpp"
43#include "logging/logTag.hpp"
44#include "logging/logStream.hpp"
45#include "memory/allocation.inline.hpp"
46#include "memory/metadataFactory.hpp"
47#include "memory/metaspaceClosure.hpp"
48#include "memory/oopFactory.hpp"
49#include "memory/resourceArea.hpp"
50#include "memory/universe.hpp"
51#include "oops/constMethod.hpp"
52#include "oops/constantPool.hpp"
53#include "oops/klass.inline.hpp"
54#include "oops/method.inline.hpp"
55#include "oops/methodData.hpp"
56#include "oops/objArrayKlass.hpp"
57#include "oops/objArrayOop.inline.hpp"
58#include "oops/oop.inline.hpp"
59#include "oops/symbol.hpp"
60#include "prims/jvmtiExport.hpp"
61#include "prims/methodHandles.hpp"
62#include "runtime/arguments.hpp"
63#include "runtime/atomic.hpp"
64#include "runtime/frame.inline.hpp"
65#include "runtime/handles.inline.hpp"
66#include "runtime/init.hpp"
67#include "runtime/orderAccess.hpp"
68#include "runtime/relocator.hpp"
69#include "runtime/safepointVerifiers.hpp"
70#include "runtime/sharedRuntime.hpp"
71#include "runtime/signature.hpp"
72#include "runtime/vm_version.hpp"
73#include "services/memTracker.hpp"
74#include "utilities/align.hpp"
75#include "utilities/quickSort.hpp"
76#include "utilities/vmError.hpp"
77#include "utilities/xmlstream.hpp"

79// Implementation of Method

81Method* Method::allocate(ClassLoaderData* loader_data,
                       int byte_code_size,
                       AccessFlags access_flags,
                       InlineTableSizes* sizes,
                       ConstMethod::MethodType method_type,
                       TRAPSJavaThread* __the_thread__) {
assert(!access_flags.is_native() || byte_code_size == 0,do { if (!(!access_flags.is_native() || byte_code_size == 0))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 88, "assert(" "!access_flags.is_native() || byte_code_size == 0"
 ") failed", "native methods should not contain byte codes");
 ::breakpoint(); } } while (0)
       "native methods should not contain byte codes")do { if (!(!access_flags.is_native() || byte_code_size == 0))
 { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 88, "assert(" "!access_flags.is_native() || byte_code_size == 0"
 ") failed", "native methods should not contain byte codes");
 ::breakpoint(); } } while (0);
ConstMethod* cm = ConstMethod::allocate(loader_data,
                                        byte_code_size,
                                        sizes,
                                        method_type,
                                        CHECK_NULL__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return __null; (void)(0);
int size = Method::size(access_flags.is_native());
return new (loader_data, size, MetaspaceObj::MethodType, THREAD__the_thread__) Method(cm, access_flags);
96}

98Method::Method(ConstMethod* xconst, AccessFlags access_flags) {
NoSafepointVerifier no_safepoint;
set_constMethod(xconst);
set_access_flags(access_flags);
set_intrinsic_id(vmIntrinsics::_none);
set_force_inline(false);
set_hidden(false);
set_dont_inline(false);
set_has_injected_profile(false);
set_method_data(NULL__null);
clear_method_counters();
set_vtable_index(Method::garbage_vtable_index);

// Fix and bury in Method*
set_interpreter_entry(NULL__null); // sets i2i entry and from_int
set_adapter_entry(NULL__null);
Method::clear_code(); // from_c/from_i get set to c2i/i2i

if (access_flags.is_native()) {
  clear_native_function();
  set_signature_handler(NULL__null);
}

NOT_PRODUCT(set_compiled_invocation_count(0);)set_compiled_invocation_count(0);
122}

124// Release Method*.  The nmethod will be gone when we get here because
125// we've walked the code cache.
126void Method::deallocate_contents(ClassLoaderData* loader_data) {
MetadataFactory::free_metadata(loader_data, constMethod());
set_constMethod(NULL__null);
MetadataFactory::free_metadata(loader_data, method_data());
set_method_data(NULL__null);
MetadataFactory::free_metadata(loader_data, method_counters());
clear_method_counters();
// The nmethod will be gone when we get here.
if (code() != NULL__null) _code = NULL__null;
135}

137void Method::release_C_heap_structures() {
if (method_data()) {
139#if INCLUDE_JVMCI1
  FailedSpeculation::free_failed_speculations(method_data()->get_failed_speculations_address());
141#endif
  // Destroy MethodData
  method_data()->~MethodData();
}
145}

147address Method::get_i2c_entry() {
assert(adapter() != NULL, "must have")do { if (!(adapter() != __null)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 148, "assert(" "adapter() != __null" ") failed", "must have"
); ::breakpoint(); } } while (0);
return adapter()->get_i2c_entry();
150}

152address Method::get_c2i_entry() {
assert(adapter() != NULL, "must have")do { if (!(adapter() != __null)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 153, "assert(" "adapter() != __null" ") failed", "must have"
); ::breakpoint(); } } while (0);
return adapter()->get_c2i_entry();
155}

157address Method::get_c2i_unverified_entry() {
assert(adapter() != NULL, "must have")do { if (!(adapter() != __null)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 158, "assert(" "adapter() != __null" ") failed", "must have"
); ::breakpoint(); } } while (0);
return adapter()->get_c2i_unverified_entry();
160}

162address Method::get_c2i_no_clinit_check_entry() {
assert(VM_Version::supports_fast_class_init_checks(), "")do { if (!(VM_Version::supports_fast_class_init_checks())) { (
*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 163, "assert(" "VM_Version::supports_fast_class_init_checks()"
 ") failed", ""); ::breakpoint(); } } while (0);
assert(adapter() != NULL, "must have")do { if (!(adapter() != __null)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 164, "assert(" "adapter() != __null" ") failed", "must have"
); ::breakpoint(); } } while (0);
return adapter()->get_c2i_no_clinit_check_entry();
166}

168char* Method::name_and_sig_as_C_string() const {
return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature());
170}

172char* Method::name_and_sig_as_C_string(char* buf, int size) const {
return name_and_sig_as_C_string(constants()->pool_holder(), name(), signature(), buf, size);
174}

176char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature) {
const char* klass_name = klass->external_name();
int klass_name_len  = (int)strlen(klass_name);
int method_name_len = method_name->utf8_length();
int len             = klass_name_len + 1 + method_name_len + signature->utf8_length();
char* dest          = NEW_RESOURCE_ARRAY(char, len + 1)(char*) resource_allocate_bytes((len + 1) * sizeof(char));
strcpy(dest, klass_name);
dest[klass_name_len] = '.';
strcpy(&dest[klass_name_len + 1], method_name->as_C_string());
strcpy(&dest[klass_name_len + 1 + method_name_len], signature->as_C_string());
dest[len] = 0;
return dest;
188}

190char* Method::name_and_sig_as_C_string(Klass* klass, Symbol* method_name, Symbol* signature, char* buf, int size) {
Symbol* klass_name = klass->name();
klass_name->as_klass_external_name(buf, size);
int len = (int)strlen(buf);

if (len < size - 1) {
  buf[len++] = '.';

  method_name->as_C_string(&(buf[len]), size - len);
  len = (int)strlen(buf);

  signature->as_C_string(&(buf[len]), size - len);
}

return buf;
205}

207const char* Method::external_name() const {
return external_name(constants()->pool_holder(), name(), signature());
209}

211void Method::print_external_name(outputStream *os) const {
print_external_name(os, constants()->pool_holder(), name(), signature());
213}

215const char* Method::external_name(Klass* klass, Symbol* method_name, Symbol* signature) {
stringStream ss;
print_external_name(&ss, klass, method_name, signature);
return ss.as_string();
219}

221void Method::print_external_name(outputStream *os, Klass* klass, Symbol* method_name, Symbol* signature) {
signature->print_as_signature_external_return_type(os);
os->print(" %s.%s(", klass->external_name(), method_name->as_C_string());
signature->print_as_signature_external_parameters(os);
os->print(")");
226}

228int Method::fast_exception_handler_bci_for(const methodHandle& mh, Klass* ex_klass, int throw_bci, TRAPSJavaThread* __the_thread__) {
if (log_is_enabled(Debug, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) {
  ResourceMark rm(THREAD__the_thread__);
  log_debug(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Debug>("Looking for catch handler for exception of type \"%s\" in method \"%s\"",
                        ex_klass == NULL__null ? "NULL" : ex_klass->external_name(), mh->name()->as_C_string());
}
// exception table holds quadruple entries of the form (beg_bci, end_bci, handler_bci, klass_index)
// access exception table
ExceptionTable table(mh());
int length = table.length();
// iterate through all entries sequentially
constantPoolHandle pool(THREAD__the_thread__, mh->constants());
for (int i = 0; i < length; i ++) {
  //reacquire the table in case a GC happened
  ExceptionTable table(mh());
  int beg_bci = table.start_pc(i);
  int end_bci = table.end_pc(i);
  assert(beg_bci <= end_bci, "inconsistent exception table")do { if (!(beg_bci <= end_bci)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 245, "assert(" "beg_bci <= end_bci" ") failed", "inconsistent exception table"
); ::breakpoint(); } } while (0);
  log_debug(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Debug>("  - checking exception table entry for BCI %d to %d",
                       beg_bci, end_bci);

  if (beg_bci <= throw_bci && throw_bci < end_bci) {
    // exception handler bci range covers throw_bci => investigate further
    log_debug(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Debug>("    - entry covers throw point BCI %d", throw_bci);

    int handler_bci = table.handler_pc(i);
    int klass_index = table.catch_type_index(i);
    if (klass_index == 0) {
      if (log_is_enabled(Info, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Info))) {
        ResourceMark rm(THREAD__the_thread__);
        log_info(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Info))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Info>("Found catch-all handler for exception of type \"%s\" in method \"%s\" at BCI: %d",
                             ex_klass == NULL__null ? "NULL" : ex_klass->external_name(), mh->name()->as_C_string(), handler_bci);
      }
      return handler_bci;
    } else if (ex_klass == NULL__null) {
      // Is this even possible?
      if (log_is_enabled(Info, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Info))) {
        ResourceMark rm(THREAD__the_thread__);
        log_info(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Info))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Info>("NULL exception class is implicitly caught by handler in method \"%s\" at BCI: %d",
                             mh()->name()->as_C_string(), handler_bci);
      }
      return handler_bci;
    } else {
      if (log_is_enabled(Debug, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) {
        ResourceMark rm(THREAD__the_thread__);
        log_debug(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Debug>("    - resolving catch type \"%s\"",
                             pool->klass_name_at(klass_index)->as_C_string());
      }
      // we know the exception class => get the constraint class
      // this may require loading of the constraint class; if verification
      // fails or some other exception occurs, return handler_bci
      Klass* k = pool->klass_at(klass_index, THREAD__the_thread__);
      if (HAS_PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->has_pending_exception())) {
        if (log_is_enabled(Debug, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) {
          ResourceMark rm(THREAD__the_thread__);
          log_debug(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Debug>("    - exception \"%s\" occurred resolving catch type",
                               PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->pending_exception())->klass()->external_name());
        }
        return handler_bci;
      }
      assert(k != NULL, "klass not loaded")do { if (!(k != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 288, "assert(" "k != __null" ") failed", "klass not loaded"
); ::breakpoint(); } } while (0);
      if (ex_klass->is_subtype_of(k)) {
        if (log_is_enabled(Info, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Info))) {
          ResourceMark rm(THREAD__the_thread__);
          log_info(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Info))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Info>("Found matching handler for exception of type \"%s\" in method \"%s\" at BCI: %d",
                               ex_klass == NULL__null ? "NULL" : ex_klass->external_name(), mh->name()->as_C_string(), handler_bci);
        }
        return handler_bci;
      }
    }
  }
}

if (log_is_enabled(Debug, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) {
  ResourceMark rm(THREAD__the_thread__);
  log_debug(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Debug>("No catch handler found for exception of type \"%s\" in method \"%s\"",
                        ex_klass->external_name(), mh->name()->as_C_string());
}

return -1;
308}

310void Method::mask_for(int bci, InterpreterOopMap* mask) {
methodHandle h_this(Thread::current(), this);
// Only GC uses the OopMapCache during thread stack root scanning
// any other uses generate an oopmap but do not save it in the cache.
if (Universe::heap()->is_gc_active()) {
  method_holder()->mask_for(h_this, bci, mask);
} else {
  OopMapCache::compute_one_oop_map(h_this, bci, mask);
}
return;
320}


323int Method::bci_from(address bcp) const {
if (is_native() && bcp == 0) {
  return 0;
}
// Do not have a ResourceMark here because AsyncGetCallTrace stack walking code
// may call this after interrupting a nested ResourceMark.
assert(is_native() && bcp == code_base() || contains(bcp) || VMError::is_error_reported(),do { if (!(is_native() && bcp == code_base() || contains
(bcp) || VMError::is_error_reported())) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 330, "assert(" "is_native() && bcp == code_base() || contains(bcp) || VMError::is_error_reported()"
 ") failed", "bcp doesn't belong to this method. bcp: " "0x%016"
 "l" "x", p2i(bcp)); ::breakpoint(); } } while (0)
       "bcp doesn't belong to this method. bcp: " INTPTR_FORMAT, p2i(bcp))do { if (!(is_native() && bcp == code_base() || contains
(bcp) || VMError::is_error_reported())) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 330, "assert(" "is_native() && bcp == code_base() || contains(bcp) || VMError::is_error_reported()"
 ") failed", "bcp doesn't belong to this method. bcp: " "0x%016"
 "l" "x", p2i(bcp)); ::breakpoint(); } } while (0);

return bcp - code_base();
333}


336int Method::validate_bci(int bci) const {
return (bci == 0 || bci < code_size()) ? bci : -1;
338}

340// Return bci if it appears to be a valid bcp
341// Return -1 otherwise.
342// Used by profiling code, when invalid data is a possibility.
343// The caller is responsible for validating the Method* itself.
344int Method::validate_bci_from_bcp(address bcp) const {
// keep bci as -1 if not a valid bci
int bci = -1;
if (bcp == 0 || bcp == code_base()) {
  // code_size() may return 0 and we allow 0 here
  // the method may be native
  bci = 0;
} else if (contains(bcp)) {
  bci = bcp - code_base();
}
// Assert that if we have dodged any asserts, bci is negative.
assert(bci == -1 || bci == bci_from(bcp_from(bci)), "sane bci if >=0")do { if (!(bci == -1 || bci == bci_from(bcp_from(bci)))) { (*
g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 355, "assert(" "bci == -1 || bci == bci_from(bcp_from(bci))"
 ") failed", "sane bci if >=0"); ::breakpoint(); } } while
 (0);
return bci;
357}

359address Method::bcp_from(int bci) const {
assert((is_native() && bci == 0) || (!is_native() && 0 <= bci && bci < code_size()),do { if (!((is_native() && bci == 0) || (!is_native()
 && 0 <= bci && bci < code_size()))) { (
*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 361, "assert(" "(is_native() && bci == 0) || (!is_native() && 0 <= bci && bci < code_size())"
 ") failed", "illegal bci: %d for %s method", bci, is_native(
) ? "native" : "non-native"); ::breakpoint(); } } while (0)
       "illegal bci: %d for %s method", bci, is_native() ? "native" : "non-native")do { if (!((is_native() && bci == 0) || (!is_native()
 && 0 <= bci && bci < code_size()))) { (
*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 361, "assert(" "(is_native() && bci == 0) || (!is_native() && 0 <= bci && bci < code_size())"
 ") failed", "illegal bci: %d for %s method", bci, is_native(
) ? "native" : "non-native"); ::breakpoint(); } } while (0);
address bcp = code_base() + bci;
assert(is_native() && bcp == code_base() || contains(bcp), "bcp doesn't belong to this method")do { if (!(is_native() && bcp == code_base() || contains
(bcp))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 363, "assert(" "is_native() && bcp == code_base() || contains(bcp)"
 ") failed", "bcp doesn't belong to this method"); ::breakpoint
(); } } while (0);
return bcp;
365}

367address Method::bcp_from(address bcp) const {
if (is_native() && bcp == NULL__null) {
  return code_base();
} else {
  return bcp;
}
373}

375int Method::size(bool is_native) {
// If native, then include pointers for native_function and signature_handler
int extra_bytes = (is_native) ? 2*sizeof(address*) : 0;
int extra_words = align_up(extra_bytes, BytesPerWord) / BytesPerWord;
return align_metadata_size(header_size() + extra_words);
380}

382Symbol* Method::klass_name() const {
return method_holder()->name();
384}

386void Method::metaspace_pointers_do(MetaspaceClosure* it) {
log_trace(cds)(!(LogImpl<(LogTag::_cds), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::is_level(LogLevel::Trace))) ? (void)0 : LogImpl<(LogTag
::_cds), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel
::Trace>("Iter(Method): %p", this);

if (!method_holder()->is_rewritten()) {
  it->push(&_constMethod, MetaspaceClosure::_writable);
} else {
  it->push(&_constMethod);
}
it->push(&_method_data);
it->push(&_method_counters);
396}

398// Attempt to return method to original state.  Clear any pointers
399// (to objects outside the shared spaces).  We won't be able to predict
400// where they should point in a new JVM.  Further initialize some
401// entries now in order allow them to be write protected later.

403void Method::remove_unshareable_info() {
unlink_method();
JFR_ONLY(REMOVE_METHOD_ID(this);)JfrTraceId::remove(this);;
406}

408void Method::set_vtable_index(int index) {
if (is_shared() && !MetaspaceShared::remapped_readwrite() && method_holder()->verified_at_dump_time()) {
  // At runtime initialize_vtable is rerun as part of link_class_impl()
  // for a shared class loaded by the non-boot loader to obtain the loader
  // constraints based on the runtime classloaders' context.
  return; // don't write into the shared class
} else {
  _vtable_index = index;
}
417}

419void Method::set_itable_index(int index) {
if (is_shared() && !MetaspaceShared::remapped_readwrite() && method_holder()->verified_at_dump_time()) {
  // At runtime initialize_itable is rerun as part of link_class_impl()
  // for a shared class loaded by the non-boot loader to obtain the loader
  // constraints based on the runtime classloaders' context. The dumptime
  // itable index should be the same as the runtime index.
  assert(_vtable_index == itable_index_max - index,do { if (!(_vtable_index == itable_index_max - index)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 426, "assert(" "_vtable_index == itable_index_max - index" ") failed"
, "archived itable index is different from runtime index"); ::
breakpoint(); } } while (0)
         "archived itable index is different from runtime index")do { if (!(_vtable_index == itable_index_max - index)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 426, "assert(" "_vtable_index == itable_index_max - index" ") failed"
, "archived itable index is different from runtime index"); ::
breakpoint(); } } while (0);
  return; // don’t write into the shared class
} else {
  _vtable_index = itable_index_max - index;
}
assert(valid_itable_index(), "")do { if (!(valid_itable_index())) { (*g_assert_poison) = 'X';
; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 431, "assert(" "valid_itable_index()" ") failed", ""); ::breakpoint
(); } } while (0);
432}

434// The RegisterNatives call being attempted tried to register with a method that
435// is not native.  Ask JVM TI what prefixes have been specified.  Then check
436// to see if the native method is now wrapped with the prefixes.  See the
437// SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
438static Method* find_prefixed_native(Klass* k, Symbol* name, Symbol* signature, TRAPSJavaThread* __the_thread__) {
439#if INCLUDE_JVMTI1
ResourceMark rm(THREAD__the_thread__);
Method* method;
int name_len = name->utf8_length();
char* name_str = name->as_utf8();
int prefix_count;
char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
for (int i = 0; i < prefix_count; i++) {
  char* prefix = prefixes[i];
  int prefix_len = (int)strlen(prefix);

  // try adding this prefix to the method name and see if it matches another method name
  int trial_len = name_len + prefix_len;
  char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1)(char*) resource_allocate_bytes((trial_len + 1) * sizeof(char
));
  strcpy(trial_name_str, prefix);
  strcat(trial_name_str, name_str);
  TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
  if (trial_name == NULL__null) {
    continue; // no such symbol, so this prefix wasn't used, try the next prefix
  }
  method = k->lookup_method(trial_name, signature);
  if (method == NULL__null) {
    continue; // signature doesn't match, try the next prefix
  }
  if (method->is_native()) {
    method->set_is_prefixed_native();
    return method; // wahoo, we found a prefixed version of the method, return it
  }
  // found as non-native, so prefix is good, add it, probably just need more prefixes
  name_len = trial_len;
  name_str = trial_name_str;
}
471#endif // INCLUDE_JVMTI
return NULL__null; // not found
473}

475bool Method::register_native(Klass* k, Symbol* name, Symbol* signature, address entry, TRAPSJavaThread* __the_thread__) {
Method* method = k->lookup_method(name, signature);
if (method == NULL__null) {
  ResourceMark rm(THREAD__the_thread__);
  stringStream st;
  st.print("Method '");
  print_external_name(&st, k, name, signature);
  st.print("' name or signature does not match");
  THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 483, vmSymbols::java_lang_NoSuchMethodError(), st.as_string
()); return false; };
}
if (!method->is_native()) {
  // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
  method = find_prefixed_native(k, name, signature, THREAD__the_thread__);
  if (method == NULL__null) {
    ResourceMark rm(THREAD__the_thread__);
    stringStream st;
    st.print("Method '");
    print_external_name(&st, k, name, signature);
    st.print("' is not declared as native");
    THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 494, vmSymbols::java_lang_NoSuchMethodError(), st.as_string
()); return false; };
  }
}

if (entry != NULL__null) {
  method->set_native_function(entry, native_bind_event_is_interesting);
} else {
  method->clear_native_function();
}
if (log_is_enabled(Debug, jni, resolve)(LogImpl<(LogTag::_jni), (LogTag::_resolve), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::is_level(LogLevel::Debug))) {
  ResourceMark rm(THREAD__the_thread__);
  log_debug(jni, resolve)(!(LogImpl<(LogTag::_jni), (LogTag::_resolve), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::is_level(LogLevel::Debug))) ? (void)0 : LogImpl<(LogTag
::_jni), (LogTag::_resolve), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG)>::write<LogLevel
::Debug>("[Registering JNI native method %s.%s]",
                          method->method_holder()->external_name(),
                          method->name()->as_C_string());
}
return true;
510}

512bool Method::was_executed_more_than(int n) {
// Invocation counter is reset when the Method* is compiled.
// If the method has compiled code we therefore assume it has
// be excuted more than n times.
if (is_accessor() || is_empty_method() || (code() != NULL__null)) {
  // interpreter doesn't bump invocation counter of trivial methods
  // compiler does not bump invocation counter of compiled methods
  return true;
}
else if ((method_counters() != NULL__null &&
          method_counters()->invocation_counter()->carry()) ||
         (method_data() != NULL__null &&
          method_data()->invocation_counter()->carry())) {
  // The carry bit is set when the counter overflows and causes
  // a compilation to occur.  We don't know how many times
  // the counter has been reset, so we simply assume it has
  // been executed more than n times.
  return true;
} else {
  return invocation_count() > n;
}
533}

535void Method::print_invocation_count() {
//---<  compose+print method return type, klass, name, and signature  >---
if (is_static()) tty->print("static ");
if (is_final()) tty->print("final ");
if (is_synchronized()) tty->print("synchronized ");
if (is_native()) tty->print("native ");
tty->print("%s::", method_holder()->external_name());
name()->print_symbol_on(tty);
signature()->print_symbol_on(tty);

if (WizardMode) {
  // dump the size of the byte codes
  tty->print(" {%d}", code_size());
}
tty->cr();

// Counting based on signed int counters tends to overflow with
// longer-running workloads on fast machines. The counters under
// consideration here, however, are limited in range by counting
// logic. See InvocationCounter:count_limit for example.
// No "overflow precautions" need to be implemented here.
tty->print_cr ("  interpreter_invocation_count: " INT32_FORMAT_W(11)"%" "11" "d", interpreter_invocation_count());
tty->print_cr ("  invocation_counter:           " INT32_FORMAT_W(11)"%" "11" "d", invocation_count());
tty->print_cr ("  backedge_counter:             " INT32_FORMAT_W(11)"%" "11" "d", backedge_count());

if (method_data() != NULL__null) {
  tty->print_cr ("  decompile_count:              " UINT32_FORMAT_W(11)"%" "11" "u", method_data()->decompile_count());
}

564#ifndef PRODUCT
if (CountCompiledCalls) {
  tty->print_cr ("  compiled_invocation_count:    " INT64_FORMAT_W(11)"%" "11" "l" "d", compiled_invocation_count());
}
568#endif
569}

571// Build a MethodData* object to hold information about this method
572// collected in the interpreter.
573void Method::build_interpreter_method_data(const methodHandle& method, TRAPSJavaThread* __the_thread__) {
// Do not profile the method if metaspace has hit an OOM previously
// allocating profiling data. Callers clear pending exception so don't
// add one here.
if (ClassLoaderDataGraph::has_metaspace_oom()) {
  return;
}

// Grab a lock here to prevent multiple
// MethodData*s from being created.
MutexLocker ml(THREAD__the_thread__, MethodData_lock);
if (method->method_data() == NULL__null) {
  ClassLoaderData* loader_data = method->method_holder()->class_loader_data();
  MethodData* method_data = MethodData::allocate(loader_data, method, THREAD__the_thread__);
  if (HAS_PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->has_pending_exception())) {
    CompileBroker::log_metaspace_failure();
    ClassLoaderDataGraph::set_metaspace_oom(true);
    return;   // return the exception (which is cleared)
  }

  method->set_method_data(method_data);
  if (PrintMethodData && (Verbose || WizardMode)) {
    ResourceMark rm(THREAD__the_thread__);
    tty->print("build_interpreter_method_data for ");
    method->print_name(tty);
    tty->cr();
    // At the end of the run, the MDO, full of data, will be dumped.
  }
}
602}

604MethodCounters* Method::build_method_counters(Thread* current, Method* m) {
// Do not profile the method if metaspace has hit an OOM previously
if (ClassLoaderDataGraph::has_metaspace_oom()) {
  return NULL__null;
}

methodHandle mh(current, m);
MethodCounters* counters;
if (current->is_Java_thread()) {
  JavaThread* THREAD__the_thread__ = JavaThread::cast(current); // For exception macros.
  // Use the TRAPS version for a JavaThread so it will adjust the GC threshold
  // if needed.
  counters = MethodCounters::allocate_with_exception(mh, THREAD__the_thread__);
  if (HAS_PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->has_pending_exception())) {
    CLEAR_PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->clear_pending_exception(
));
  }
} else {
  // Call metaspace allocation that doesn't throw exception if the
  // current thread isn't a JavaThread, ie. the VMThread.
  counters = MethodCounters::allocate_no_exception(mh);
}

if (counters == NULL__null) {
  CompileBroker::log_metaspace_failure();
  ClassLoaderDataGraph::set_metaspace_oom(true);
  return NULL__null;
}

if (!mh->init_method_counters(counters)) {
  MetadataFactory::free_metadata(mh->method_holder()->class_loader_data(), counters);
}

if (LogTouchedMethods) {
  mh->log_touched(current);
}

return mh->method_counters();
641}

643bool Method::init_method_counters(MethodCounters* counters) {
// Try to install a pointer to MethodCounters, return true on success.
return Atomic::replace_if_null(&_method_counters, counters);
646}

648int Method::extra_stack_words() {
// not an inline function, to avoid a header dependency on Interpreter
return extra_stack_entries() * Interpreter::stackElementSize;
651}

653// Derive size of parameters, return type, and fingerprint,
654// all in one pass, which is run at load time.
655// We need the first two, and might as well grab the third.
656void Method::compute_from_signature(Symbol* sig) {
// At this point, since we are scanning the signature,
// we might as well compute the whole fingerprint.
Fingerprinter fp(sig, is_static());
set_size_of_parameters(fp.size_of_parameters());
constMethod()->set_result_type(fp.return_type());
constMethod()->set_fingerprint(fp.fingerprint());
663}

665bool Method::is_vanilla_constructor() const {
// Returns true if this method is a vanilla constructor, i.e. an "<init>" "()V" method
// which only calls the superclass vanilla constructor and possibly does stores of
// zero constants to local fields:
//
//   aload_0
//   invokespecial
//   indexbyte1
//   indexbyte2
//
// followed by an (optional) sequence of:
//
//   aload_0
//   aconst_null / iconst_0 / fconst_0 / dconst_0
//   putfield
//   indexbyte1
//   indexbyte2
//
// followed by:
//
//   return

assert(name() == vmSymbols::object_initializer_name(),    "Should only be called for default constructors")do { if (!(name() == vmSymbols::object_initializer_name())) {
 (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 687, "assert(" "name() == vmSymbols::object_initializer_name()"
 ") failed", "Should only be called for default constructors"
); ::breakpoint(); } } while (0);
assert(signature() == vmSymbols::void_method_signature(), "Should only be called for default constructors")do { if (!(signature() == vmSymbols::void_method_signature())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 688, "assert(" "signature() == vmSymbols::void_method_signature()"
 ") failed", "Should only be called for default constructors"
); ::breakpoint(); } } while (0);
int size = code_size();
// Check if size match
if (size == 0 || size % 5 != 0) return false;
address cb = code_base();
int last = size - 1;
if (cb[0] != Bytecodes::_aload_0 || cb[1] != Bytecodes::_invokespecial || cb[last] != Bytecodes::_return) {
  // Does not call superclass default constructor
  return false;
}
// Check optional sequence
for (int i = 4; i < last; i += 5) {
  if (cb[i] != Bytecodes::_aload_0) return false;
  if (!Bytecodes::is_zero_const(Bytecodes::cast(cb[i+1]))) return false;
  if (cb[i+2] != Bytecodes::_putfield) return false;
}
return true;
705}


708bool Method::compute_has_loops_flag() {
BytecodeStream bcs(methodHandle(Thread::current(), this));
Bytecodes::Code bc;

while ((bc = bcs.next()) >= 0) {
  switch (bc) {
    case Bytecodes::_ifeq:
    case Bytecodes::_ifnull:
    case Bytecodes::_iflt:
    case Bytecodes::_ifle:
    case Bytecodes::_ifne:
    case Bytecodes::_ifnonnull:
    case Bytecodes::_ifgt:
    case Bytecodes::_ifge:
    case Bytecodes::_if_icmpeq:
    case Bytecodes::_if_icmpne:
    case Bytecodes::_if_icmplt:
    case Bytecodes::_if_icmpgt:
    case Bytecodes::_if_icmple:
    case Bytecodes::_if_icmpge:
    case Bytecodes::_if_acmpeq:
    case Bytecodes::_if_acmpne:
    case Bytecodes::_goto:
    case Bytecodes::_jsr:
      if (bcs.dest() < bcs.next_bci()) _access_flags.set_has_loops();
      break;

    case Bytecodes::_goto_w:
    case Bytecodes::_jsr_w:
      if (bcs.dest_w() < bcs.next_bci()) _access_flags.set_has_loops();
      break;

    case Bytecodes::_lookupswitch: {
      Bytecode_lookupswitch lookupswitch(this, bcs.bcp());
      if (lookupswitch.default_offset() < 0) {
        _access_flags.set_has_loops();
      } else {
        for (int i = 0; i < lookupswitch.number_of_pairs(); ++i) {
          LookupswitchPair pair = lookupswitch.pair_at(i);
          if (pair.offset() < 0) {
            _access_flags.set_has_loops();
            break;
          }
        }
      }
      break;
    }
    case Bytecodes::_tableswitch: {
      Bytecode_tableswitch tableswitch(this, bcs.bcp());
      if (tableswitch.default_offset() < 0) {
        _access_flags.set_has_loops();
      } else {
        for (int i = 0; i < tableswitch.length(); ++i) {
          if (tableswitch.dest_offset_at(i) < 0) {
            _access_flags.set_has_loops();
          }
        }
      }
      break;
    }
    default:
      break;
  }
}
_access_flags.set_loops_flag_init();
return _access_flags.has_loops();
774}

776bool Method::is_final_method(AccessFlags class_access_flags) const {
// or "does_not_require_vtable_entry"
// default method or overpass can occur, is not final (reuses vtable entry)
// private methods in classes get vtable entries for backward class compatibility.
if (is_overpass() || is_default_method())  return false;
return is_final() || class_access_flags.is_final();
782}

784bool Method::is_final_method() const {
return is_final_method(method_holder()->access_flags());
786}

788bool Method::is_default_method() const {
if (method_holder() != NULL__null &&
    method_holder()->is_interface() &&
    !is_abstract() && !is_private()) {
  return true;
} else {
  return false;
}
796}

798bool Method::can_be_statically_bound(AccessFlags class_access_flags) const {
if (is_final_method(class_access_flags))  return true;
800#ifdef ASSERT1
ResourceMark rm;
bool is_nonv = (vtable_index() == nonvirtual_vtable_index);
if (class_access_flags.is_interface()) {
    assert(is_nonv == is_static() || is_nonv == is_private(),do { if (!(is_nonv == is_static() || is_nonv == is_private())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 806, "assert(" "is_nonv == is_static() || is_nonv == is_private()"
 ") failed", "nonvirtual unexpected for non-static, non-private: %s"
, name_and_sig_as_C_string()); ::breakpoint(); } } while (0)
           "nonvirtual unexpected for non-static, non-private: %s",do { if (!(is_nonv == is_static() || is_nonv == is_private())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 806, "assert(" "is_nonv == is_static() || is_nonv == is_private()"
 ") failed", "nonvirtual unexpected for non-static, non-private: %s"
, name_and_sig_as_C_string()); ::breakpoint(); } } while (0)
           name_and_sig_as_C_string())do { if (!(is_nonv == is_static() || is_nonv == is_private())
) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 806, "assert(" "is_nonv == is_static() || is_nonv == is_private()"
 ") failed", "nonvirtual unexpected for non-static, non-private: %s"
, name_and_sig_as_C_string()); ::breakpoint(); } } while (0);
}
808#endif
assert(valid_vtable_index() || valid_itable_index(), "method must be linked before we ask this question")do { if (!(valid_vtable_index() || valid_itable_index())) { (
*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 809, "assert(" "valid_vtable_index() || valid_itable_index()"
 ") failed", "method must be linked before we ask this question"
); ::breakpoint(); } } while (0);
return vtable_index() == nonvirtual_vtable_index;
811}

813bool Method::can_be_statically_bound() const {
return can_be_statically_bound(method_holder()->access_flags());
815}

817bool Method::can_be_statically_bound(InstanceKlass* context) const {
return (method_holder() == context) && can_be_statically_bound();
819}

821/**
*  Returns false if this is one of specially treated methods for
*  which we have to provide stack trace in throw in compiled code.
*  Returns true otherwise.
*/
826bool Method::can_omit_stack_trace() {
if (klass_name() == vmSymbols::sun_invoke_util_ValueConversions()) {
  return false; // All methods in sun.invoke.util.ValueConversions
}
return true;
831}

833bool Method::is_accessor() const {
return is_getter() || is_setter();
835}

837bool Method::is_getter() const {
if (code_size() != 5) return false;
if (size_of_parameters() != 1) return false;
if (java_code_at(0) != Bytecodes::_aload_0)  return false;
if (java_code_at(1) != Bytecodes::_getfield) return false;
switch (java_code_at(4)) {
  case Bytecodes::_ireturn:
  case Bytecodes::_lreturn:
  case Bytecodes::_freturn:
  case Bytecodes::_dreturn:
  case Bytecodes::_areturn:
    break;
  default:
    return false;
}
return true;
853}

855bool Method::is_setter() const {
if (code_size() != 6) return false;
if (java_code_at(0) != Bytecodes::_aload_0) return false;
switch (java_code_at(1)) {
  case Bytecodes::_iload_1:
  case Bytecodes::_aload_1:
  case Bytecodes::_fload_1:
    if (size_of_parameters() != 2) return false;
    break;
  case Bytecodes::_dload_1:
  case Bytecodes::_lload_1:
    if (size_of_parameters() != 3) return false;
    break;
  default:
    return false;
}
if (java_code_at(2) != Bytecodes::_putfield) return false;
if (java_code_at(5) != Bytecodes::_return)   return false;
return true;
874}

876bool Method::is_constant_getter() const {
int last_index = code_size() - 1;
// Check if the first 1-3 bytecodes are a constant push
// and the last bytecode is a return.
return (2 <= code_size() && code_size() <= 4 &&
        Bytecodes::is_const(java_code_at(0)) &&
        Bytecodes::length_for(java_code_at(0)) == last_index &&
        Bytecodes::is_return(java_code_at(last_index)));
884}

886bool Method::is_initializer() const {
return is_object_initializer() || is_static_initializer();
888}

890bool Method::has_valid_initializer_flags() const {
return (is_static() ||
        method_holder()->major_version() < 51);
893}

895bool Method::is_static_initializer() const {
// For classfiles version 51 or greater, ensure that the clinit method is
// static.  Non-static methods with the name "<clinit>" are not static
// initializers. (older classfiles exempted for backward compatibility)
return name() == vmSymbols::class_initializer_name() &&
       has_valid_initializer_flags();
901}

903bool Method::is_object_initializer() const {
 return name() == vmSymbols::object_initializer_name();
905}

907bool Method::needs_clinit_barrier() const {
return is_static() && !method_holder()->is_initialized();
909}

911objArrayHandle Method::resolved_checked_exceptions_impl(Method* method, TRAPSJavaThread* __the_thread__) {
int length = method->checked_exceptions_length();
if (length == 0) {  // common case
  return objArrayHandle(THREAD__the_thread__, Universe::the_empty_class_array());
} else {
  methodHandle h_this(THREAD__the_thread__, method);
  objArrayOop m_oop = oopFactory::new_objArray(vmClasses::Class_klass(), length, CHECK_(objArrayHandle())__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return objArrayHandle(); (void)(0);
  objArrayHandle mirrors (THREAD__the_thread__, m_oop);
  for (int i = 0; i < length; i++) {
    CheckedExceptionElement* table = h_this->checked_exceptions_start(); // recompute on each iteration, not gc safe
    Klass* k = h_this->constants()->klass_at(table[i].class_cp_index, CHECK_(objArrayHandle())__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return objArrayHandle(); (void)(0);
    if (log_is_enabled(Warning, exceptions)(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Warning)) &&
        !k->is_subclass_of(vmClasses::Throwable_klass())) {
      ResourceMark rm(THREAD__the_thread__);
      log_warning(exceptions)(!(LogImpl<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Warning))) ? (void)0 : LogImpl
<(LogTag::_exceptions), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Warning>(
        "Class %s in throws clause of method %s is not a subtype of class java.lang.Throwable",
        k->external_name(), method->external_name());
    }
    mirrors->obj_at_put(i, k->java_mirror());
  }
  return mirrors;
}
933};


936int Method::line_number_from_bci(int bci) const {
int best_bci  =  0;
int best_line = -1;
if (bci == SynchronizationEntryBCI) bci = 0;
if (0 <= bci && bci < code_size() && has_linenumber_table()) {
  // The line numbers are a short array of 2-tuples [start_pc, line_number].
  // Not necessarily sorted and not necessarily one-to-one.
  CompressedLineNumberReadStream stream(compressed_linenumber_table());
  while (stream.read_pair()) {
    if (stream.bci() == bci) {
      // perfect match
      return stream.line();
    } else {
      // update best_bci/line
      if (stream.bci() < bci && stream.bci() >= best_bci) {
        best_bci  = stream.bci();
        best_line = stream.line();
      }
    }
  }
}
return best_line;
958}


961bool Method::is_klass_loaded_by_klass_index(int klass_index) const {
if( constants()->tag_at(klass_index).is_unresolved_klass() ) {
  Thread *thread = Thread::current();
  Symbol* klass_name = constants()->klass_name_at(klass_index);
  Handle loader(thread, method_holder()->class_loader());
  Handle prot  (thread, method_holder()->protection_domain());
  return SystemDictionary::find_instance_klass(klass_name, loader, prot) != NULL__null;
} else {
  return true;
}
971}


974bool Method::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
int klass_index = constants()->klass_ref_index_at(refinfo_index);
if (must_be_resolved) {
  // Make sure klass is resolved in constantpool.
  if (constants()->tag_at(klass_index).is_unresolved_klass()) return false;
}
return is_klass_loaded_by_klass_index(klass_index);
981}


984void Method::set_native_function(address function, bool post_event_flag) {
assert(function != NULL, "use clear_native_function to unregister natives")do { if (!(function != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 985, "assert(" "function != __null" ") failed", "use clear_native_function to unregister natives"
); ::breakpoint(); } } while (0);
assert(!is_method_handle_intrinsic() || function == SharedRuntime::native_method_throw_unsatisfied_link_error_entry(), "")do { if (!(!is_method_handle_intrinsic() || function == SharedRuntime
::native_method_throw_unsatisfied_link_error_entry())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 986, "assert(" "!is_method_handle_intrinsic() || function == SharedRuntime::native_method_throw_unsatisfied_link_error_entry()"
 ") failed", ""); ::breakpoint(); } } while (0);
address* native_function = native_function_addr();

// We can see racers trying to place the same native function into place. Once
// is plenty.
address current = *native_function;
if (current == function) return;
if (post_event_flag && JvmtiExport::should_post_native_method_bind() &&
    function != NULL__null) {
  // native_method_throw_unsatisfied_link_error_entry() should only
  // be passed when post_event_flag is false.
  assert(function !=do { if (!(function != SharedRuntime::native_method_throw_unsatisfied_link_error_entry
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 999, "assert(" "function != SharedRuntime::native_method_throw_unsatisfied_link_error_entry()"
 ") failed", "post_event_flag mis-match"); ::breakpoint(); } }
 while (0)
    SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),do { if (!(function != SharedRuntime::native_method_throw_unsatisfied_link_error_entry
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 999, "assert(" "function != SharedRuntime::native_method_throw_unsatisfied_link_error_entry()"
 ") failed", "post_event_flag mis-match"); ::breakpoint(); } }
 while (0)
    "post_event_flag mis-match")do { if (!(function != SharedRuntime::native_method_throw_unsatisfied_link_error_entry
())) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 999, "assert(" "function != SharedRuntime::native_method_throw_unsatisfied_link_error_entry()"
 ") failed", "post_event_flag mis-match"); ::breakpoint(); } }
 while (0);

  // post the bind event, and possible change the bind function
  JvmtiExport::post_native_method_bind(this, &function);
}
*native_function = function;
// This function can be called more than once. We must make sure that we always
// use the latest registered method -> check if a stub already has been generated.
// If so, we have to make it not_entrant.
CompiledMethod* nm = code(); // Put it into local variable to guard against concurrent updates
if (nm != NULL__null) {
  nm->make_not_entrant();
}
1012}


1015bool Method::has_native_function() const {
if (is_method_handle_intrinsic())
  return false;  // special-cased in SharedRuntime::generate_native_wrapper
address func = native_function();
return (func != NULL__null && func != SharedRuntime::native_method_throw_unsatisfied_link_error_entry());
1020}


1023void Method::clear_native_function() {
// Note: is_method_handle_intrinsic() is allowed here.
set_native_function(
  SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
  !native_bind_event_is_interesting);
this->unlink_code();
1029}


1032void Method::set_signature_handler(address handler) {
address* signature_handler =  signature_handler_addr();
*signature_handler = handler;
1035}


1038void Method::print_made_not_compilable(int comp_level, bool is_osr, bool report, const char* reason) {
assert(reason != NULL, "must provide a reason")do { if (!(reason != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1039, "assert(" "reason != __null" ") failed", "must provide a reason"
); ::breakpoint(); } } while (0);
if (PrintCompilation && report) {
  ttyLocker ttyl;
  tty->print("made not %scompilable on ", is_osr ? "OSR " : "");
  if (comp_level == CompLevel_all) {
    tty->print("all levels ");
  } else {
    tty->print("level %d ", comp_level);
  }
  this->print_short_name(tty);
  int size = this->code_size();
  if (size > 0) {
    tty->print(" (%d bytes)", size);
  }
  if (reason != NULL__null) {
    tty->print("   %s", reason);
  }
  tty->cr();
}
if ((TraceDeoptimization || LogCompilation) && (xtty != NULL__null)) {
  ttyLocker ttyl;
  xtty->begin_elem("make_not_compilable thread='" UINTX_FORMAT"%" "l" "u" "' osr='%d' level='%d'",
                   os::current_thread_id(), is_osr, comp_level);
  if (reason != NULL__null) {
    xtty->print(" reason=\'%s\'", reason);
  }
  xtty->method(this);
  xtty->stamp();
  xtty->end_elem();
}
1069}

1071bool Method::is_always_compilable() const {
// Generated adapters must be compiled
if (is_method_handle_intrinsic() && is_synthetic()) {
  assert(!is_not_c1_compilable(), "sanity check")do { if (!(!is_not_c1_compilable())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1074, "assert(" "!is_not_c1_compilable()" ") failed", "sanity check"
); ::breakpoint(); } } while (0);
  assert(!is_not_c2_compilable(), "sanity check")do { if (!(!is_not_c2_compilable())) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1075, "assert(" "!is_not_c2_compilable()" ") failed", "sanity check"
); ::breakpoint(); } } while (0);
  return true;
}

return false;
1080}

1082bool Method::is_not_compilable(int comp_level) const {
if (number_of_breakpoints() > 0)
  return true;
if (is_always_compilable())
  return false;
if (comp_level == CompLevel_any)
  return is_not_c1_compilable() && is_not_c2_compilable();
if (is_c1_compile(comp_level))
  return is_not_c1_compilable();
if (is_c2_compile(comp_level))
  return is_not_c2_compilable();
return false;
1094}

1096// call this when compiler finds that this method is not compilable
1097void Method::set_not_compilable(const char* reason, int comp_level, bool report) {
if (is_always_compilable()) {
  // Don't mark a method which should be always compilable
  return;
}
print_made_not_compilable(comp_level, /*is_osr*/ false, report, reason);
if (comp_level == CompLevel_all) {
  set_not_c1_compilable();
  set_not_c2_compilable();
} else {
  if (is_c1_compile(comp_level))
    set_not_c1_compilable();
  if (is_c2_compile(comp_level))
    set_not_c2_compilable();
}
assert(!CompilationPolicy::can_be_compiled(methodHandle(Thread::current(), this), comp_level), "sanity check")do { if (!(!CompilationPolicy::can_be_compiled(methodHandle(Thread
::current(), this), comp_level))) { (*g_assert_poison) = 'X';
; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1112, "assert(" "!CompilationPolicy::can_be_compiled(methodHandle(Thread::current(), this), comp_level)"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);
1113}

1115bool Method::is_not_osr_compilable(int comp_level) const {
if (is_not_compilable(comp_level))
  return true;
if (comp_level == CompLevel_any)
  return is_not_c1_osr_compilable() && is_not_c2_osr_compilable();
if (is_c1_compile(comp_level))
  return is_not_c1_osr_compilable();
if (is_c2_compile(comp_level))
  return is_not_c2_osr_compilable();
return false;
1125}

1127void Method::set_not_osr_compilable(const char* reason, int comp_level, bool report) {
print_made_not_compilable(comp_level, /*is_osr*/ true, report, reason);
if (comp_level == CompLevel_all) {
  set_not_c1_osr_compilable();
  set_not_c2_osr_compilable();
} else {
  if (is_c1_compile(comp_level))
    set_not_c1_osr_compilable();
  if (is_c2_compile(comp_level))
    set_not_c2_osr_compilable();
}
assert(!CompilationPolicy::can_be_osr_compiled(methodHandle(Thread::current(), this), comp_level), "sanity check")do { if (!(!CompilationPolicy::can_be_osr_compiled(methodHandle
(Thread::current(), this), comp_level))) { (*g_assert_poison)
 = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1138, "assert(" "!CompilationPolicy::can_be_osr_compiled(methodHandle(Thread::current(), this), comp_level)"
 ") failed", "sanity check"); ::breakpoint(); } } while (0);
1139}

1141// Revert to using the interpreter and clear out the nmethod
1142void Method::clear_code() {
// this may be NULL if c2i adapters have not been made yet
// Only should happen at allocate time.
if (adapter() == NULL__null) {
  _from_compiled_entry    = NULL__null;
} else {
  _from_compiled_entry    = adapter()->get_c2i_entry();
}
OrderAccess::storestore();
_from_interpreted_entry = _i2i_entry;
OrderAccess::storestore();
_code = NULL__null;
1154}

1156void Method::unlink_code(CompiledMethod *compare) {
MutexLocker ml(CompiledMethod_lock->owned_by_self() ? NULL__null : CompiledMethod_lock, Mutex::_no_safepoint_check_flag);
// We need to check if either the _code or _from_compiled_code_entry_point
// refer to this nmethod because there is a race in setting these two fields
// in Method* as seen in bugid 4947125.
// If the vep() points to the zombie nmethod, the memory for the nmethod
// could be flushed and the compiler and vtable stubs could still call
// through it.
if (code() == compare ||
    from_compiled_entry() == compare->verified_entry_point()) {
  clear_code();
}
1168}

1170void Method::unlink_code() {
MutexLocker ml(CompiledMethod_lock->owned_by_self() ? NULL__null : CompiledMethod_lock, Mutex::_no_safepoint_check_flag);
clear_code();
1173}

1175#if INCLUDE_CDS1
1176// Called by class data sharing to remove any entry points (which are not shared)
1177void Method::unlink_method() {
Arguments::assert_is_dumping_archive();
_code = NULL__null;
_adapter = NULL__null;
_i2i_entry = NULL__null;
_from_compiled_entry = NULL__null;
_from_interpreted_entry = NULL__null;

if (is_native()) {
  *native_function_addr() = NULL__null;
  set_signature_handler(NULL__null);
}
NOT_PRODUCT(set_compiled_invocation_count(0);)set_compiled_invocation_count(0);

set_method_data(NULL__null);
clear_method_counters();
1193}
1194#endif

1196// Called when the method_holder is getting linked. Setup entrypoints so the method
1197// is ready to be called from interpreter, compiler, and vtables.
1198void Method::link_method(const methodHandle& h_method, TRAPSJavaThread* __the_thread__) {
// If the code cache is full, we may reenter this function for the
// leftover methods that weren't linked.
if (_i2i_entry != NULL__null) {
  return;
}
assert( _code == NULL, "nothing compiled yet" )do { if (!(_code == __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1204, "assert(" "_code == __null" ") failed", "nothing compiled yet"
); ::breakpoint(); } } while (0);

// Setup interpreter entrypoint
assert(this == h_method(), "wrong h_method()" )do { if (!(this == h_method())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1207, "assert(" "this == h_method()" ") failed", "wrong h_method()"
); ::breakpoint(); } } while (0);

assert(adapter() == NULL, "init'd to NULL")do { if (!(adapter() == __null)) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1209, "assert(" "adapter() == __null" ") failed", "init'd to NULL"
); ::breakpoint(); } } while (0);
address entry = Interpreter::entry_for_method(h_method);
assert(entry != NULL, "interpreter entry must be non-null")do { if (!(entry != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1211, "assert(" "entry != __null" ") failed", "interpreter entry must be non-null"
); ::breakpoint(); } } while (0);
// Sets both _i2i_entry and _from_interpreted_entry
set_interpreter_entry(entry);

// Don't overwrite already registered native entries.
if (is_native() && !has_native_function()) {
  set_native_function(
    SharedRuntime::native_method_throw_unsatisfied_link_error_entry(),
    !native_bind_event_is_interesting);
}

// Setup compiler entrypoint.  This is made eagerly, so we do not need
// special handling of vtables.  An alternative is to make adapters more
// lazily by calling make_adapter() from from_compiled_entry() for the
// normal calls.  For vtable calls life gets more complicated.  When a
// call-site goes mega-morphic we need adapters in all methods which can be
// called from the vtable.  We need adapters on such methods that get loaded
// later.  Ditto for mega-morphic itable calls.  If this proves to be a
// problem we'll make these lazily later.
(void) make_adapters(h_method, CHECK__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return ; (void)(0);

// ONLY USE the h_method now as make_adapter may have blocked
1233}

1235address Method::make_adapters(const methodHandle& mh, TRAPSJavaThread* __the_thread__) {
// Adapters for compiled code are made eagerly here.  They are fairly
// small (generally < 100 bytes) and quick to make (and cached and shared)
// so making them eagerly shouldn't be too expensive.
AdapterHandlerEntry* adapter = AdapterHandlerLibrary::get_adapter(mh);
if (adapter == NULL__null ) {
  if (!is_init_completed()) {
    // Don't throw exceptions during VM initialization because java.lang.* classes
    // might not have been initialized, causing problems when constructing the
    // Java exception object.
    vm_exit_during_initialization("Out of space in CodeCache for adapters");
  } else {
    THROW_MSG_NULL(vmSymbols::java_lang_VirtualMachineError(), "Out of space in CodeCache for adapters"){ Exceptions::_throw_msg(__the_thread__, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1247, vmSymbols::java_lang_VirtualMachineError(), "Out of space in CodeCache for adapters"
); return __null; };
  }
}

mh->set_adapter_entry(adapter);
mh->_from_compiled_entry = adapter->get_c2i_entry();
return adapter->get_c2i_entry();
1254}

1256void Method::restore_unshareable_info(TRAPSJavaThread* __the_thread__) {
assert(is_method() && is_valid_method(this), "ensure C++ vtable is restored")do { if (!(is_method() && is_valid_method(this))) { (
*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1257, "assert(" "is_method() && is_valid_method(this)"
 ") failed", "ensure C++ vtable is restored"); ::breakpoint()
; } } while (0);
1
Assuming the condition is true→
2
←
Calling 'Method::is_valid_method'→
1258}

1260address Method::from_compiled_entry_no_trampoline() const {
CompiledMethod *code = Atomic::load_acquire(&_code);
if (code) {
  return code->verified_entry_point();
} else {
  return adapter()->get_c2i_entry();
}
1267}

1269// The verified_code_entry() must be called when a invoke is resolved
1270// on this method.

1272// It returns the compiled code entry point, after asserting not null.
1273// This function is called after potential safepoints so that nmethod
1274// or adapter that it points to is still live and valid.
1275// This function must not hit a safepoint!
1276address Method::verified_code_entry() {
debug_only(NoSafepointVerifier nsv;)NoSafepointVerifier nsv;
assert(_from_compiled_entry != NULL, "must be set")do { if (!(_from_compiled_entry != __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1278, "assert(" "_from_compiled_entry != __null" ") failed"
, "must be set"); ::breakpoint(); } } while (0);
return _from_compiled_entry;
1280}

1282// Check that if an nmethod ref exists, it has a backlink to this or no backlink at all
1283// (could be racing a deopt).
1284// Not inline to avoid circular ref.
1285bool Method::check_code() const {
// cached in a register or local.  There's a race on the value of the field.
CompiledMethod *code = Atomic::load_acquire(&_code);
return code == NULL__null || (code->method() == NULL__null) || (code->method() == (Method*)this && !code->is_osr_method());
1289}

1291// Install compiled code.  Instantly it can execute.
1292void Method::set_code(const methodHandle& mh, CompiledMethod *code) {
assert_lock_strong(CompiledMethod_lock);
assert( code, "use clear_code to remove code" )do { if (!(code)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1294, "assert(" "code" ") failed", "use clear_code to remove code"
); ::breakpoint(); } } while (0);
assert( mh->check_code(), "" )do { if (!(mh->check_code())) { (*g_assert_poison) = 'X';;
 report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1295, "assert(" "mh->check_code()" ") failed", ""); ::breakpoint
(); } } while (0);

guarantee(mh->adapter() != NULL, "Adapter blob must already exist!")do { if (!(mh->adapter() != __null)) { (*g_assert_poison) =
 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1297, "guarantee(" "mh->adapter() != NULL" ") failed", "Adapter blob must already exist!"
); ::breakpoint(); } } while (0);

// These writes must happen in this order, because the interpreter will
// directly jump to from_interpreted_entry which jumps to an i2c adapter
// which jumps to _from_compiled_entry.
mh->_code = code;             // Assign before allowing compiled code to exec

int comp_level = code->comp_level();
// In theory there could be a race here. In practice it is unlikely
// and not worth worrying about.
if (comp_level > mh->highest_comp_level()) {
  mh->set_highest_comp_level(comp_level);
}

OrderAccess::storestore();
mh->_from_compiled_entry = code->verified_entry_point();
OrderAccess::storestore();
// Instantly compiled code can execute.
if (!mh->is_method_handle_intrinsic())
  mh->_from_interpreted_entry = mh->get_i2c_entry();
1317}


1320bool Method::is_overridden_in(Klass* k) const {
InstanceKlass* ik = InstanceKlass::cast(k);

if (ik->is_interface()) return false;

// If method is an interface, we skip it - except if it
// is a miranda method
if (method_holder()->is_interface()) {
  // Check that method is not a miranda method
  if (ik->lookup_method(name(), signature()) == NULL__null) {
    // No implementation exist - so miranda method
    return false;
  }
  return true;
}

assert(ik->is_subclass_of(method_holder()), "should be subklass")do { if (!(ik->is_subclass_of(method_holder()))) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1336, "assert(" "ik->is_subclass_of(method_holder())" ") failed"
, "should be subklass"); ::breakpoint(); } } while (0);
if (!has_vtable_index()) {
  return false;
} else {
  Method* vt_m = ik->method_at_vtable(vtable_index());
  return vt_m != this;
}
1343}


1346// give advice about whether this Method* should be cached or not
1347bool Method::should_not_be_cached() const {
if (is_old()) {
  // This method has been redefined. It is either EMCP or obsolete
  // and we don't want to cache it because that would pin the method
  // down and prevent it from being collectible if and when it
  // finishes executing.
  return true;
}

// caching this method should be just fine
return false;
1358}


1361/**
*  Returns true if this is one of the specially treated methods for
*  security related stack walks (like Reflection.getCallerClass).
*/
1365bool Method::is_ignored_by_security_stack_walk() const {
if (intrinsic_id() == vmIntrinsics::_invoke) {
  // This is Method.invoke() -- ignore it
  return true;
}
if (method_holder()->is_subclass_of(vmClasses::reflect_MethodAccessorImpl_klass())) {
  // This is an auxilary frame -- ignore it
  return true;
}
if (is_method_handle_intrinsic() || is_compiled_lambda_form()) {
  // This is an internal adapter frame for method handles -- ignore it
  return true;
}
return false;
1379}


1382// Constant pool structure for invoke methods:
1383enum {
_imcp_invoke_name = 1,        // utf8: 'invokeExact', etc.
_imcp_invoke_signature,       // utf8: (variable Symbol*)
_imcp_limit
1387};

1389// Test if this method is an MH adapter frame generated by Java code.
1390// Cf. java/lang/invoke/InvokerBytecodeGenerator
1391bool Method::is_compiled_lambda_form() const {
return intrinsic_id() == vmIntrinsics::_compiledLambdaForm;
1393}

1395// Test if this method is an internal MH primitive method.
1396bool Method::is_method_handle_intrinsic() const {
vmIntrinsics::ID iid = intrinsic_id();
return (MethodHandles::is_signature_polymorphic(iid) &&
        MethodHandles::is_signature_polymorphic_intrinsic(iid));
1400}

1402bool Method::has_member_arg() const {
vmIntrinsics::ID iid = intrinsic_id();
return (MethodHandles::is_signature_polymorphic(iid) &&
        MethodHandles::has_member_arg(iid));
1406}

1408// Make an instance of a signature-polymorphic internal MH primitive.
1409methodHandle Method::make_method_handle_intrinsic(vmIntrinsics::ID iid,
                                                       Symbol* signature,
                                                       TRAPSJavaThread* __the_thread__) {
ResourceMark rm(THREAD__the_thread__);
methodHandle empty;

InstanceKlass* holder = vmClasses::MethodHandle_klass();
Symbol* name = MethodHandles::signature_polymorphic_intrinsic_name(iid);
assert(iid == MethodHandles::signature_polymorphic_name_id(name), "")do { if (!(iid == MethodHandles::signature_polymorphic_name_id
(name))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1417, "assert(" "iid == MethodHandles::signature_polymorphic_name_id(name)"
 ") failed", ""); ::breakpoint(); } } while (0);

log_info(methodhandles)(!(LogImpl<(LogTag::_methodhandles), (LogTag::__NO_TAG), (
LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag
::__NO_TAG)>::is_level(LogLevel::Info))) ? (void)0 : LogImpl
<(LogTag::_methodhandles), (LogTag::__NO_TAG), (LogTag::__NO_TAG
), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG)
>::write<LogLevel::Info>("make_method_handle_intrinsic MH.%s%s", name->as_C_string(), signature->as_C_string());

// invariant:   cp->symbol_at_put is preceded by a refcount increment (more usually a lookup)
name->increment_refcount();
signature->increment_refcount();

int cp_length = _imcp_limit;
ClassLoaderData* loader_data = holder->class_loader_data();
constantPoolHandle cp;
{
  ConstantPool* cp_oop = ConstantPool::allocate(loader_data, cp_length, CHECK_(empty)__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return empty; (void)(0);
  cp = constantPoolHandle(THREAD__the_thread__, cp_oop);
}
cp->copy_fields(holder->constants());
cp->set_pool_holder(holder);
cp->symbol_at_put(_imcp_invoke_name,       name);
cp->symbol_at_put(_imcp_invoke_signature,  signature);
cp->set_has_preresolution();

// decide on access bits:  public or not?
int flags_bits = (JVM_ACC_NATIVE | JVM_ACC_SYNTHETIC | JVM_ACC_FINAL);
bool must_be_static = MethodHandles::is_signature_polymorphic_static(iid);
if (must_be_static)  flags_bits |= JVM_ACC_STATIC;
assert((flags_bits & JVM_ACC_PUBLIC) == 0, "do not expose these methods")do { if (!((flags_bits & JVM_ACC_PUBLIC) == 0)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1442, "assert(" "(flags_bits & JVM_ACC_PUBLIC) == 0" ") failed"
, "do not expose these methods"); ::breakpoint(); } } while (
0);

methodHandle m;
{
  InlineTableSizes sizes;
  Method* m_oop = Method::allocate(loader_data, 0,
                                   accessFlags_from(flags_bits), &sizes,
                                   ConstMethod::NORMAL, CHECK_(empty)__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return empty; (void)(0);
  m = methodHandle(THREAD__the_thread__, m_oop);
}
m->set_constants(cp());
m->set_name_index(_imcp_invoke_name);
m->set_signature_index(_imcp_invoke_signature);
assert(MethodHandles::is_signature_polymorphic_name(m->name()), "")do { if (!(MethodHandles::is_signature_polymorphic_name(m->
name()))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1455, "assert(" "MethodHandles::is_signature_polymorphic_name(m->name())"
 ") failed", ""); ::breakpoint(); } } while (0);
assert(m->signature() == signature, "")do { if (!(m->signature() == signature)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1456, "assert(" "m->signature() == signature" ") failed"
, ""); ::breakpoint(); } } while (0);
m->compute_from_signature(signature);
m->init_intrinsic_id(klass_id_for_intrinsics(m->method_holder()));
assert(m->is_method_handle_intrinsic(), "")do { if (!(m->is_method_handle_intrinsic())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1459, "assert(" "m->is_method_handle_intrinsic()" ") failed"
, ""); ::breakpoint(); } } while (0);
1460#ifdef ASSERT1
if (!MethodHandles::is_signature_polymorphic(m->intrinsic_id()))  m->print();
assert(MethodHandles::is_signature_polymorphic(m->intrinsic_id()), "must be an invoker")do { if (!(MethodHandles::is_signature_polymorphic(m->intrinsic_id
()))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1462, "assert(" "MethodHandles::is_signature_polymorphic(m->intrinsic_id())"
 ") failed", "must be an invoker"); ::breakpoint(); } } while
 (0);
assert(m->intrinsic_id() == iid, "correctly predicted iid")do { if (!(m->intrinsic_id() == iid)) { (*g_assert_poison)
 = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1463, "assert(" "m->intrinsic_id() == iid" ") failed", "correctly predicted iid"
); ::breakpoint(); } } while (0);
1464#endif //ASSERT

// Finally, set up its entry points.
assert(m->can_be_statically_bound(), "")do { if (!(m->can_be_statically_bound())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1467, "assert(" "m->can_be_statically_bound()" ") failed"
, ""); ::breakpoint(); } } while (0);
m->set_vtable_index(Method::nonvirtual_vtable_index);
m->link_method(m, CHECK_(empty)__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return empty; (void)(0);

if (iid == vmIntrinsics::_linkToNative) {
  m->set_interpreter_entry(m->adapter()->get_i2c_entry());
}
if (log_is_enabled(Info, methodhandles)(LogImpl<(LogTag::_methodhandles), (LogTag::__NO_TAG), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG)>::is_level(LogLevel::Info)) && (Verbose || WizardMode)) {
  LogTarget(Info, methodhandles)LogTargetImpl<LogLevel::Info, (LogTag::_methodhandles), (LogTag
::__NO_TAG), (LogTag::__NO_TAG), (LogTag::__NO_TAG), (LogTag::
__NO_TAG), (LogTag::__NO_TAG)> lt;
  LogStream ls(lt);
  m->print_on(&ls);
}

return m;
1481}

1483Klass* Method::check_non_bcp_klass(Klass* klass) {
if (klass != NULL__null && klass->class_loader() != NULL__null) {
  if (klass->is_objArray_klass())
    klass = ObjArrayKlass::cast(klass)->bottom_klass();
  return klass;
}
return NULL__null;
1490}


1493methodHandle Method::clone_with_new_data(const methodHandle& m, u_char* new_code, int new_code_length,
                                              u_char* new_compressed_linenumber_table, int new_compressed_linenumber_size, TRAPSJavaThread* __the_thread__) {
// Code below does not work for native methods - they should never get rewritten anyway
assert(!m->is_native(), "cannot rewrite native methods")do { if (!(!m->is_native())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1496, "assert(" "!m->is_native()" ") failed", "cannot rewrite native methods"
); ::breakpoint(); } } while (0);
// Allocate new Method*
AccessFlags flags = m->access_flags();

ConstMethod* cm = m->constMethod();
int checked_exceptions_len = cm->checked_exceptions_length();
int localvariable_len = cm->localvariable_table_length();
int exception_table_len = cm->exception_table_length();
int method_parameters_len = cm->method_parameters_length();
int method_annotations_len = cm->method_annotations_length();
int parameter_annotations_len = cm->parameter_annotations_length();
int type_annotations_len = cm->type_annotations_length();
int default_annotations_len = cm->default_annotations_length();

InlineTableSizes sizes(
    localvariable_len,
    new_compressed_linenumber_size,
    exception_table_len,
    checked_exceptions_len,
    method_parameters_len,
    cm->generic_signature_index(),
    method_annotations_len,
    parameter_annotations_len,
    type_annotations_len,
    default_annotations_len,
    0);

ClassLoaderData* loader_data = m->method_holder()->class_loader_data();
Method* newm_oop = Method::allocate(loader_data,
                                    new_code_length,
                                    flags,
                                    &sizes,
                                    m->method_type(),
                                    CHECK_(methodHandle())__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return methodHandle(); (void)(0);
methodHandle newm (THREAD__the_thread__, newm_oop);

// Create a shallow copy of Method part, but be careful to preserve the new ConstMethod*
ConstMethod* newcm = newm->constMethod();
int new_const_method_size = newm->constMethod()->size();

// This works because the source and target are both Methods. Some compilers
// (e.g., clang) complain that the target vtable pointer will be stomped,
// so cast away newm()'s and m()'s Methodness.
memcpy((void*)newm(), (void*)m(), sizeof(Method));

// Create shallow copy of ConstMethod.
memcpy(newcm, m->constMethod(), sizeof(ConstMethod));

// Reset correct method/const method, method size, and parameter info
newm->set_constMethod(newcm);
newm->constMethod()->set_code_size(new_code_length);
newm->constMethod()->set_constMethod_size(new_const_method_size);
assert(newm->code_size() == new_code_length, "check")do { if (!(newm->code_size() == new_code_length)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1548, "assert(" "newm->code_size() == new_code_length" ") failed"
, "check"); ::breakpoint(); } } while (0);
assert(newm->method_parameters_length() == method_parameters_len, "check")do { if (!(newm->method_parameters_length() == method_parameters_len
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1549, "assert(" "newm->method_parameters_length() == method_parameters_len"
 ") failed", "check"); ::breakpoint(); } } while (0);
assert(newm->checked_exceptions_length() == checked_exceptions_len, "check")do { if (!(newm->checked_exceptions_length() == checked_exceptions_len
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1550, "assert(" "newm->checked_exceptions_length() == checked_exceptions_len"
 ") failed", "check"); ::breakpoint(); } } while (0);
assert(newm->exception_table_length() == exception_table_len, "check")do { if (!(newm->exception_table_length() == exception_table_len
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1551, "assert(" "newm->exception_table_length() == exception_table_len"
 ") failed", "check"); ::breakpoint(); } } while (0);
assert(newm->localvariable_table_length() == localvariable_len, "check")do { if (!(newm->localvariable_table_length() == localvariable_len
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1552, "assert(" "newm->localvariable_table_length() == localvariable_len"
 ") failed", "check"); ::breakpoint(); } } while (0);
// Copy new byte codes
memcpy(newm->code_base(), new_code, new_code_length);
// Copy line number table
if (new_compressed_linenumber_size > 0) {
  memcpy(newm->compressed_linenumber_table(),
         new_compressed_linenumber_table,
         new_compressed_linenumber_size);
}
// Copy method_parameters
if (method_parameters_len > 0) {
  memcpy(newm->method_parameters_start(),
         m->method_parameters_start(),
         method_parameters_len * sizeof(MethodParametersElement));
}
// Copy checked_exceptions
if (checked_exceptions_len > 0) {
  memcpy(newm->checked_exceptions_start(),
         m->checked_exceptions_start(),
         checked_exceptions_len * sizeof(CheckedExceptionElement));
}
// Copy exception table
if (exception_table_len > 0) {
  memcpy(newm->exception_table_start(),
         m->exception_table_start(),
         exception_table_len * sizeof(ExceptionTableElement));
}
// Copy local variable number table
if (localvariable_len > 0) {
  memcpy(newm->localvariable_table_start(),
         m->localvariable_table_start(),
         localvariable_len * sizeof(LocalVariableTableElement));
}
// Copy stackmap table
if (m->has_stackmap_table()) {
  int code_attribute_length = m->stackmap_data()->length();
  Array<u1>* stackmap_data =
    MetadataFactory::new_array<u1>(loader_data, code_attribute_length, 0, CHECK_(methodHandle())__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return methodHandle(); (void)(0);
  memcpy((void*)stackmap_data->adr_at(0),
         (void*)m->stackmap_data()->adr_at(0), code_attribute_length);
  newm->set_stackmap_data(stackmap_data);
}

// copy annotations over to new method
newcm->copy_annotations_from(loader_data, cm, CHECK_(methodHandle())__the_thread__); if ((((ThreadShadow*)__the_thread__)->has_pending_exception
())) return methodHandle(); (void)(0);
return newm;
1598}

1600vmSymbolID Method::klass_id_for_intrinsics(const Klass* holder) {
// if loader is not the default loader (i.e., != NULL), we can't know the intrinsics
// because we are not loading from core libraries
// exception: the AES intrinsics come from lib/ext/sunjce_provider.jar
// which does not use the class default class loader so we check for its loader here
const InstanceKlass* ik = InstanceKlass::cast(holder);
if ((ik->class_loader() != NULL__null) && !SystemDictionary::is_platform_class_loader(ik->class_loader())) {
  return vmSymbolID::NO_SID;   // regardless of name, no intrinsics here
}

// see if the klass name is well-known:
Symbol* klass_name = ik->name();
vmSymbolID id = vmSymbols::find_sid(klass_name);
if (id != vmSymbolID::NO_SID && vmIntrinsics::class_has_intrinsics(id)) {
  return id;
} else {
  return vmSymbolID::NO_SID;
}
1618}

1620void Method::init_intrinsic_id(vmSymbolID klass_id) {
assert(_intrinsic_id == static_cast<int>(vmIntrinsics::_none), "do this just once")do { if (!(_intrinsic_id == static_cast<int>(vmIntrinsics
::_none))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1621, "assert(" "_intrinsic_id == static_cast<int>(vmIntrinsics::_none)"
 ") failed", "do this just once"); ::breakpoint(); } } while (
0);
const uintptr_t max_id_uint = right_n_bits((int)(sizeof(_intrinsic_id) * BitsPerByte))(((((int)(sizeof(_intrinsic_id) * BitsPerByte)) >= BitsPerWord
) ? 0 : (OneBit << ((int)(sizeof(_intrinsic_id) * BitsPerByte
)))) - 1);
assert((uintptr_t)vmIntrinsics::ID_LIMIT <= max_id_uint, "else fix size")do { if (!((uintptr_t)vmIntrinsics::ID_LIMIT <= max_id_uint
)) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1623, "assert(" "(uintptr_t)vmIntrinsics::ID_LIMIT <= max_id_uint"
 ") failed", "else fix size"); ::breakpoint(); } } while (0);
assert(intrinsic_id_size_in_bytes() == sizeof(_intrinsic_id), "")do { if (!(intrinsic_id_size_in_bytes() == sizeof(_intrinsic_id
))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1624, "assert(" "intrinsic_id_size_in_bytes() == sizeof(_intrinsic_id)"
 ") failed", ""); ::breakpoint(); } } while (0);

// the klass name is well-known:
assert(klass_id == klass_id_for_intrinsics(method_holder()), "must be")do { if (!(klass_id == klass_id_for_intrinsics(method_holder(
)))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1627, "assert(" "klass_id == klass_id_for_intrinsics(method_holder())"
 ") failed", "must be"); ::breakpoint(); } } while (0);
assert(klass_id != vmSymbolID::NO_SID, "caller responsibility")do { if (!(klass_id != vmSymbolID::NO_SID)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1628, "assert(" "klass_id != vmSymbolID::NO_SID" ") failed"
, "caller responsibility"); ::breakpoint(); } } while (0);

// ditto for method and signature:
vmSymbolID name_id = vmSymbols::find_sid(name());
if (klass_id != VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle)vmSymbolID::java_lang_invoke_MethodHandle_enum
    && klass_id != VM_SYMBOL_ENUM_NAME(java_lang_invoke_VarHandle)vmSymbolID::java_lang_invoke_VarHandle_enum
    && name_id == vmSymbolID::NO_SID) {
  return;
}
vmSymbolID sig_id = vmSymbols::find_sid(signature());
if (klass_id != VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle)vmSymbolID::java_lang_invoke_MethodHandle_enum
    && klass_id != VM_SYMBOL_ENUM_NAME(java_lang_invoke_VarHandle)vmSymbolID::java_lang_invoke_VarHandle_enum
    && sig_id == vmSymbolID::NO_SID) {
  return;
}
jshort flags = access_flags().as_short();

vmIntrinsics::ID id = vmIntrinsics::find_id(klass_id, name_id, sig_id, flags);
if (id != vmIntrinsics::_none) {
  set_intrinsic_id(id);
  if (id == vmIntrinsics::_Class_cast) {
    // Even if the intrinsic is rejected, we want to inline this simple method.
    set_force_inline(true);
  }
  return;
}

// A few slightly irregular cases:
switch (klass_id) {
// Signature-polymorphic methods: MethodHandle.invoke*, InvokeDynamic.*., VarHandle
case VM_SYMBOL_ENUM_NAME(java_lang_invoke_MethodHandle)vmSymbolID::java_lang_invoke_MethodHandle_enum:
case VM_SYMBOL_ENUM_NAME(java_lang_invoke_VarHandle)vmSymbolID::java_lang_invoke_VarHandle_enum:
  if (!is_native())  break;
  id = MethodHandles::signature_polymorphic_name_id(method_holder(), name());
  if (is_static() != MethodHandles::is_signature_polymorphic_static(id))
    id = vmIntrinsics::_none;
  break;

default:
  break;
}

if (id != vmIntrinsics::_none) {
  // Set up its iid.  It is an alias method.
  set_intrinsic_id(id);
  return;
}
1675}

1677bool Method::load_signature_classes(const methodHandle& m, TRAPSJavaThread* __the_thread__) {
if (!THREAD__the_thread__->can_call_java()) {
  // There is nothing useful this routine can do from within the Compile thread.
  // Hopefully, the signature contains only well-known classes.
  // We could scan for this and return true/false, but the caller won't care.
  return false;
}
bool sig_is_loaded = true;
ResourceMark rm(THREAD__the_thread__);
for (ResolvingSignatureStream ss(m()); !ss.is_done(); ss.next()) {
  if (ss.is_reference()) {
    // load everything, including arrays "[Lfoo;"
    Klass* klass = ss.as_klass(SignatureStream::ReturnNull, THREAD__the_thread__);
    // We are loading classes eagerly. If a ClassNotFoundException or
    // a LinkageError was generated, be sure to ignore it.
    if (HAS_PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->has_pending_exception())) {
      if (PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->pending_exception())->is_a(vmClasses::ClassNotFoundException_klass()) ||
          PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->pending_exception())->is_a(vmClasses::LinkageError_klass())) {
        CLEAR_PENDING_EXCEPTION(((ThreadShadow*)__the_thread__)->clear_pending_exception(
));
      } else {
        return false;
      }
    }
    if( klass == NULL__null) { sig_is_loaded = false; }
  }
}
return sig_is_loaded;
1704}

1706bool Method::has_unloaded_classes_in_signature(const methodHandle& m, TRAPSJavaThread* __the_thread__) {
ResourceMark rm(THREAD__the_thread__);
for(ResolvingSignatureStream ss(m()); !ss.is_done(); ss.next()) {
  if (ss.type() == T_OBJECT) {
    // Do not use ss.is_reference() here, since we don't care about
    // unloaded array component types.
    Klass* klass = ss.as_klass_if_loaded(THREAD__the_thread__);
    assert(!HAS_PENDING_EXCEPTION, "as_klass_if_loaded contract")do { if (!(!(((ThreadShadow*)__the_thread__)->has_pending_exception
()))) { (*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1713, "assert(" "!(((ThreadShadow*)__the_thread__)->has_pending_exception())"
 ") failed", "as_klass_if_loaded contract"); ::breakpoint(); }
 } while (0);
    if (klass == NULL__null) return true;
  }
}
return false;
1718}

1720// Exposed so field engineers can debug VM
1721void Method::print_short_name(outputStream* st) {
ResourceMark rm;
1723#ifdef PRODUCT
st->print(" %s::", method_holder()->external_name());
1725#else
st->print(" %s::", method_holder()->internal_name());
1727#endif
name()->print_symbol_on(st);
if (WizardMode) signature()->print_symbol_on(st);
else if (MethodHandles::is_signature_polymorphic(intrinsic_id()))
  MethodHandles::print_as_basic_type_signature_on(st, signature());
1732}

1734// Comparer for sorting an object array containing
1735// Method*s.
1736static int method_comparator(Method* a, Method* b) {
return a->name()->fast_compare(b->name());
1738}

1740// This is only done during class loading, so it is OK to assume method_idnum matches the methods() array
1741// default_methods also uses this without the ordering for fast find_method
1742void Method::sort_methods(Array<Method*>* methods, bool set_idnums, method_comparator_func func) {
int length = methods->length();
if (length > 1) {
  if (func == NULL__null) {
    func = method_comparator;
  }
  {
    NoSafepointVerifier nsv;
    QuickSort::sort(methods->data(), length, func, /*idempotent=*/false);
  }
  // Reset method ordering
  if (set_idnums) {
    for (int i = 0; i < length; i++) {
      Method* m = methods->at(i);
      m->set_method_idnum(i);
      m->set_orig_method_idnum(i);
    }
  }
}
1761}

1763//-----------------------------------------------------------------------------------
1764// Non-product code unless JVM/TI needs it

1766#if !defined(PRODUCT) || INCLUDE_JVMTI1
1767class SignatureTypePrinter : public SignatureTypeNames {
private:
outputStream* _st;
bool _use_separator;

void type_name(const char* name) {
  if (_use_separator) _st->print(", ");
  _st->print("%s", name);
  _use_separator = true;
}

public:
SignatureTypePrinter(Symbol* signature, outputStream* st) : SignatureTypeNames(signature) {
  _st = st;
  _use_separator = false;
}

void print_parameters()              { _use_separator = false; do_parameters_on(this); }
void print_returntype()              { _use_separator = false; do_type(return_type()); }
1786};


1789void Method::print_name(outputStream* st) {
Thread *thread = Thread::current();
ResourceMark rm(thread);
st->print("%s ", is_static() ? "static" : "virtual");
if (WizardMode) {
  st->print("%s.", method_holder()->internal_name());
  name()->print_symbol_on(st);
  signature()->print_symbol_on(st);
} else {
  SignatureTypePrinter sig(signature(), st);
  sig.print_returntype();
  st->print(" %s.", method_holder()->internal_name());
  name()->print_symbol_on(st);
  st->print("(");
  sig.print_parameters();
  st->print(")");
}
1806}
1807#endif // !PRODUCT || INCLUDE_JVMTI


1810void Method::print_codes_on(outputStream* st) const {
print_codes_on(0, code_size(), st);
1812}

1814void Method::print_codes_on(int from, int to, outputStream* st) const {
Thread *thread = Thread::current();
ResourceMark rm(thread);
methodHandle mh (thread, (Method*)this);
BytecodeStream s(mh);
s.set_interval(from, to);
BytecodeTracer::set_closure(BytecodeTracer::std_closure());
while (s.next() >= 0) BytecodeTracer::trace(mh, s.bcp(), st);
1822}

1824CompressedLineNumberReadStream::CompressedLineNumberReadStream(u_char* buffer) : CompressedReadStream(buffer) {
_bci = 0;
_line = 0;
1827};

1829bool CompressedLineNumberReadStream::read_pair() {
jubyte next = read_byte();
// Check for terminator
if (next == 0) return false;
if (next == 0xFF) {
  // Escape character, regular compression used
  _bci  += read_signed_int();
  _line += read_signed_int();
} else {
  // Single byte compression used
  _bci  += next >> 3;
  _line += next & 0x7;
}
return true;
1843}

1845#if INCLUDE_JVMTI1

1847Bytecodes::Code Method::orig_bytecode_at(int bci) const {
BreakpointInfo* bp = method_holder()->breakpoints();
for (; bp != NULL__null; bp = bp->next()) {
  if (bp->match(this, bci)) {
    return bp->orig_bytecode();
  }
}
{
  ResourceMark rm;
  fatal("no original bytecode found in %s at bci %d", name_and_sig_as_C_string(), bci)do { (*g_assert_poison) = 'X';; report_fatal(INTERNAL_ERROR, "/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1856, "no original bytecode found in %s at bci %d", name_and_sig_as_C_string
(), bci); ::breakpoint(); } while (0);
}
return Bytecodes::_shouldnotreachhere;
1859}

1861void Method::set_orig_bytecode_at(int bci, Bytecodes::Code code) {
assert(code != Bytecodes::_breakpoint, "cannot patch breakpoints this way")do { if (!(code != Bytecodes::_breakpoint)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1862, "assert(" "code != Bytecodes::_breakpoint" ") failed"
, "cannot patch breakpoints this way"); ::breakpoint(); } } while
 (0);
BreakpointInfo* bp = method_holder()->breakpoints();
for (; bp != NULL__null; bp = bp->next()) {
  if (bp->match(this, bci)) {
    bp->set_orig_bytecode(code);
    // and continue, in case there is more than one
  }
}
1870}

1872void Method::set_breakpoint(int bci) {
InstanceKlass* ik = method_holder();
BreakpointInfo *bp = new BreakpointInfo(this, bci);
bp->set_next(ik->breakpoints());
ik->set_breakpoints(bp);
// do this last:
bp->set(this);
1879}

1881static void clear_matches(Method* m, int bci) {
InstanceKlass* ik = m->method_holder();
BreakpointInfo* prev_bp = NULL__null;
BreakpointInfo* next_bp;
for (BreakpointInfo* bp = ik->breakpoints(); bp != NULL__null; bp = next_bp) {
  next_bp = bp->next();
  // bci value of -1 is used to delete all breakpoints in method m (ex: clear_all_breakpoint).
  if (bci >= 0 ? bp->match(m, bci) : bp->match(m)) {
    // do this first:
    bp->clear(m);
    // unhook it
    if (prev_bp != NULL__null)
      prev_bp->set_next(next_bp);
    else
      ik->set_breakpoints(next_bp);
    delete bp;
    // When class is redefined JVMTI sets breakpoint in all versions of EMCP methods
    // at same location. So we have multiple matching (method_index and bci)
    // BreakpointInfo nodes in BreakpointInfo list. We should just delete one
    // breakpoint for clear_breakpoint request and keep all other method versions
    // BreakpointInfo for future clear_breakpoint request.
    // bcivalue of -1 is used to clear all breakpoints (see clear_all_breakpoints)
    // which is being called when class is unloaded. We delete all the Breakpoint
    // information for all versions of method. We may not correctly restore the original
    // bytecode in all method versions, but that is ok. Because the class is being unloaded
    // so these methods won't be used anymore.
    if (bci >= 0) {
      break;
    }
  } else {
    // This one is a keeper.
    prev_bp = bp;
  }
}
1915}

1917void Method::clear_breakpoint(int bci) {
assert(bci >= 0, "")do { if (!(bci >= 0)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 1918, "assert(" "bci >= 0" ") failed", ""); ::breakpoint
(); } } while (0);
clear_matches(this, bci);
1920}

1922void Method::clear_all_breakpoints() {
clear_matches(this, -1);
1924}

1926#endif // INCLUDE_JVMTI

1928int Method::invocation_count() const {
MethodCounters* mcs = method_counters();
MethodData* mdo = method_data();
if (((mcs != NULL__null) ? mcs->invocation_counter()->carry() : false) ||
    ((mdo != NULL__null) ? mdo->invocation_counter()->carry() : false)) {
  return InvocationCounter::count_limit;
} else {
  return ((mcs != NULL__null) ? mcs->invocation_counter()->count() : 0) +
         ((mdo != NULL__null) ? mdo->invocation_counter()->count() : 0);
}
1938}

1940int Method::backedge_count() const {
MethodCounters* mcs = method_counters();
MethodData* mdo = method_data();
if (((mcs != NULL__null) ? mcs->backedge_counter()->carry() : false) ||
    ((mdo != NULL__null) ? mdo->backedge_counter()->carry() : false)) {
  return InvocationCounter::count_limit;
} else {
  return ((mcs != NULL__null) ? mcs->backedge_counter()->count() : 0) +
         ((mdo != NULL__null) ? mdo->backedge_counter()->count() : 0);
}
1950}

1952int Method::highest_comp_level() const {
const MethodCounters* mcs = method_counters();
if (mcs != NULL__null) {
  return mcs->highest_comp_level();
} else {
  return CompLevel_none;
}
1959}

1961int Method::highest_osr_comp_level() const {
const MethodCounters* mcs = method_counters();
if (mcs != NULL__null) {
  return mcs->highest_osr_comp_level();
} else {
  return CompLevel_none;
}
1968}

1970void Method::set_highest_comp_level(int level) {
MethodCounters* mcs = method_counters();
if (mcs != NULL__null) {
  mcs->set_highest_comp_level(level);
}
1975}

1977void Method::set_highest_osr_comp_level(int level) {
MethodCounters* mcs = method_counters();
if (mcs != NULL__null) {
  mcs->set_highest_osr_comp_level(level);
}
1982}

1984#if INCLUDE_JVMTI1

1986BreakpointInfo::BreakpointInfo(Method* m, int bci) {
_bci = bci;
_name_index = m->name_index();
_signature_index = m->signature_index();
_orig_bytecode = (Bytecodes::Code) *m->bcp_from(_bci);
if (_orig_bytecode == Bytecodes::_breakpoint)
  _orig_bytecode = m->orig_bytecode_at(_bci);
_next = NULL__null;
1994}

1996void BreakpointInfo::set(Method* method) {
1997#ifdef ASSERT1
{
  Bytecodes::Code code = (Bytecodes::Code) *method->bcp_from(_bci);
  if (code == Bytecodes::_breakpoint)
    code = method->orig_bytecode_at(_bci);
  assert(orig_bytecode() == code, "original bytecode must be the same")do { if (!(orig_bytecode() == code)) { (*g_assert_poison) = 'X'
;; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2002, "assert(" "orig_bytecode() == code" ") failed", "original bytecode must be the same"
); ::breakpoint(); } } while (0);
}
2004#endif
Thread *thread = Thread::current();
*method->bcp_from(_bci) = Bytecodes::_breakpoint;
method->incr_number_of_breakpoints(thread);
{
  // Deoptimize all dependents on this method
  HandleMark hm(thread);
  methodHandle mh(thread, method);
  CodeCache::flush_dependents_on_method(mh);
}
2014}

2016void BreakpointInfo::clear(Method* method) {
*method->bcp_from(_bci) = orig_bytecode();
assert(method->number_of_breakpoints() > 0, "must not go negative")do { if (!(method->number_of_breakpoints() > 0)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2018, "assert(" "method->number_of_breakpoints() > 0"
 ") failed", "must not go negative"); ::breakpoint(); } } while
 (0);
method->decr_number_of_breakpoints(Thread::current());
2020}

2022#endif // INCLUDE_JVMTI

2024// jmethodID handling

2026// This is a block allocating object, sort of like JNIHandleBlock, only a
2027// lot simpler.
2028// It's allocated on the CHeap because once we allocate a jmethodID, we can
2029// never get rid of it.

2031static const int min_block_size = 8;

2033class JNIMethodBlockNode : public CHeapObj<mtClass> {
friend class JNIMethodBlock;
Method**        _methods;
int             _number_of_methods;
int             _top;
JNIMethodBlockNode* _next;

public:

JNIMethodBlockNode(int num_methods = min_block_size);

~JNIMethodBlockNode() { FREE_C_HEAP_ARRAY(Method*, _methods)FreeHeap((char*)(_methods)); }

void ensure_methods(int num_addl_methods) {
  if (_top < _number_of_methods) {
    num_addl_methods -= _number_of_methods - _top;
    if (num_addl_methods <= 0) {
      return;
    }
  }
  if (_next == NULL__null) {
    _next = new JNIMethodBlockNode(MAX2(num_addl_methods, min_block_size));
  } else {
    _next->ensure_methods(num_addl_methods);
  }
}
2059};

2061class JNIMethodBlock : public CHeapObj<mtClass> {
JNIMethodBlockNode _head;
JNIMethodBlockNode *_last_free;
public:
static Method* const _free_method;

JNIMethodBlock(int initial_capacity = min_block_size)
    : _head(initial_capacity), _last_free(&_head) {}

void ensure_methods(int num_addl_methods) {
  _last_free->ensure_methods(num_addl_methods);
}

Method** add_method(Method* m) {
  for (JNIMethodBlockNode* b = _last_free; b != NULL__null; b = b->_next) {
    if (b->_top < b->_number_of_methods) {
      // top points to the next free entry.
      int i = b->_top;
      b->_methods[i] = m;
      b->_top++;
      _last_free = b;
      return &(b->_methods[i]);
    } else if (b->_top == b->_number_of_methods) {
      // if the next free entry ran off the block see if there's a free entry
      for (int i = 0; i < b->_number_of_methods; i++) {
        if (b->_methods[i] == _free_method) {
          b->_methods[i] = m;
          _last_free = b;
          return &(b->_methods[i]);
        }
      }
      // Only check each block once for frees.  They're very unlikely.
      // Increment top past the end of the block.
      b->_top++;
    }
    // need to allocate a next block.
    if (b->_next == NULL__null) {
      b->_next = _last_free = new JNIMethodBlockNode();
    }
  }
  guarantee(false, "Should always allocate a free block")do { if (!(false)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2101, "guarantee(" "false" ") failed", "Should always allocate a free block"
); ::breakpoint(); } } while (0);
  return NULL__null;
}

bool contains(Method** m) {
  if (m == NULL__null) return false;
  for (JNIMethodBlockNode* b = &_head; b != NULL__null; b = b->_next) {
    if (b->_methods <= m && m < b->_methods + b->_number_of_methods) {
      // This is a bit of extra checking, for two reasons.  One is
      // that contains() deals with pointers that are passed in by
      // JNI code, so making sure that the pointer is aligned
      // correctly is valuable.  The other is that <= and > are
      // technically not defined on pointers, so the if guard can
      // pass spuriously; no modern compiler is likely to make that
      // a problem, though (and if one did, the guard could also
      // fail spuriously, which would be bad).
      ptrdiff_t idx = m - b->_methods;
      if (b->_methods + idx == m) {
        return true;
      }
    }
  }
  return false;  // not found
}

// Doesn't really destroy it, just marks it as free so it can be reused.
void destroy_method(Method** m) {
2128#ifdef ASSERT1
  assert(contains(m), "should be a methodID")do { if (!(contains(m))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2129, "assert(" "contains(m)" ") failed", "should be a methodID"
); ::breakpoint(); } } while (0);
2130#endif // ASSERT
  *m = _free_method;
}

// During class unloading the methods are cleared, which is different
// than freed.
void clear_all_methods() {
  for (JNIMethodBlockNode* b = &_head; b != NULL__null; b = b->_next) {
    for (int i = 0; i< b->_number_of_methods; i++) {
      b->_methods[i] = NULL__null;
    }
  }
}
2143#ifndef PRODUCT
int count_methods() {
  // count all allocated methods
  int count = 0;
  for (JNIMethodBlockNode* b = &_head; b != NULL__null; b = b->_next) {
    for (int i = 0; i< b->_number_of_methods; i++) {
      if (b->_methods[i] != _free_method) count++;
    }
  }
  return count;
}
2154#endif // PRODUCT
2155};

2157// Something that can't be mistaken for an address or a markWord
2158Method* const JNIMethodBlock::_free_method = (Method*)55;

2160JNIMethodBlockNode::JNIMethodBlockNode(int num_methods) : _top(0), _next(NULL__null) {
_number_of_methods = MAX2(num_methods, min_block_size);
_methods = NEW_C_HEAP_ARRAY(Method*, _number_of_methods, mtInternal)(Method**) (AllocateHeap((_number_of_methods) * sizeof(Method
*), mtInternal));
for (int i = 0; i < _number_of_methods; i++) {
  _methods[i] = JNIMethodBlock::_free_method;
}
2166}

2168void Method::ensure_jmethod_ids(ClassLoaderData* loader_data, int capacity) {
ClassLoaderData* cld = loader_data;
if (!SafepointSynchronize::is_at_safepoint()) {
  // Have to add jmethod_ids() to class loader data thread-safely.
  // Also have to add the method to the list safely, which the lock
  // protects as well.
  MutexLocker ml(JmethodIdCreation_lock,  Mutex::_no_safepoint_check_flag);
  if (cld->jmethod_ids() == NULL__null) {
    cld->set_jmethod_ids(new JNIMethodBlock(capacity));
  } else {
    cld->jmethod_ids()->ensure_methods(capacity);
  }
} else {
  // At safepoint, we are single threaded and can set this.
  if (cld->jmethod_ids() == NULL__null) {
    cld->set_jmethod_ids(new JNIMethodBlock(capacity));
  } else {
    cld->jmethod_ids()->ensure_methods(capacity);
  }
}
2188}

2190// Add a method id to the jmethod_ids
2191jmethodID Method::make_jmethod_id(ClassLoaderData* loader_data, Method* m) {
ClassLoaderData* cld = loader_data;

if (!SafepointSynchronize::is_at_safepoint()) {
  // Have to add jmethod_ids() to class loader data thread-safely.
  // Also have to add the method to the list safely, which the lock
  // protects as well.
  MutexLocker ml(JmethodIdCreation_lock,  Mutex::_no_safepoint_check_flag);
  if (cld->jmethod_ids() == NULL__null) {
    cld->set_jmethod_ids(new JNIMethodBlock());
  }
  // jmethodID is a pointer to Method*
  return (jmethodID)cld->jmethod_ids()->add_method(m);
} else {
  // At safepoint, we are single threaded and can set this.
  if (cld->jmethod_ids() == NULL__null) {
    cld->set_jmethod_ids(new JNIMethodBlock());
  }
  // jmethodID is a pointer to Method*
  return (jmethodID)cld->jmethod_ids()->add_method(m);
}
2212}

2214jmethodID Method::jmethod_id() {
methodHandle mh(Thread::current(), this);
return method_holder()->get_jmethod_id(mh);
2217}

2219// Mark a jmethodID as free.  This is called when there is a data race in
2220// InstanceKlass while creating the jmethodID cache.
2221void Method::destroy_jmethod_id(ClassLoaderData* loader_data, jmethodID m) {
ClassLoaderData* cld = loader_data;
Method** ptr = (Method**)m;
assert(cld->jmethod_ids() != NULL, "should have method handles")do { if (!(cld->jmethod_ids() != __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2224, "assert(" "cld->jmethod_ids() != __null" ") failed"
, "should have method handles"); ::breakpoint(); } } while (0
);
cld->jmethod_ids()->destroy_method(ptr);
2226}

2228void Method::change_method_associated_with_jmethod_id(jmethodID jmid, Method* new_method) {
// Can't assert the method_holder is the same because the new method has the
// scratch method holder.
assert(resolve_jmethod_id(jmid)->method_holder()->class_loader()do { if (!(resolve_jmethod_id(jmid)->method_holder()->class_loader
() == new_method->method_holder()->class_loader() || new_method
->method_holder()->class_loader() == __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2234, "assert(" "resolve_jmethod_id(jmid)->method_holder()->class_loader() == new_method->method_holder()->class_loader() || new_method->method_holder()->class_loader() == __null"
 ") failed", "changing to a different class loader"); ::breakpoint
(); } } while (0)
         == new_method->method_holder()->class_loader() ||do { if (!(resolve_jmethod_id(jmid)->method_holder()->class_loader
() == new_method->method_holder()->class_loader() || new_method
->method_holder()->class_loader() == __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2234, "assert(" "resolve_jmethod_id(jmid)->method_holder()->class_loader() == new_method->method_holder()->class_loader() || new_method->method_holder()->class_loader() == __null"
 ") failed", "changing to a different class loader"); ::breakpoint
(); } } while (0)
         new_method->method_holder()->class_loader() == NULL, // allow Unsafe substitutiondo { if (!(resolve_jmethod_id(jmid)->method_holder()->class_loader
() == new_method->method_holder()->class_loader() || new_method
->method_holder()->class_loader() == __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2234, "assert(" "resolve_jmethod_id(jmid)->method_holder()->class_loader() == new_method->method_holder()->class_loader() || new_method->method_holder()->class_loader() == __null"
 ") failed", "changing to a different class loader"); ::breakpoint
(); } } while (0)
       "changing to a different class loader")do { if (!(resolve_jmethod_id(jmid)->method_holder()->class_loader
() == new_method->method_holder()->class_loader() || new_method
->method_holder()->class_loader() == __null)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2234, "assert(" "resolve_jmethod_id(jmid)->method_holder()->class_loader() == new_method->method_holder()->class_loader() || new_method->method_holder()->class_loader() == __null"
 ") failed", "changing to a different class loader"); ::breakpoint
(); } } while (0);
// Just change the method in place, jmethodID pointer doesn't change.
*((Method**)jmid) = new_method;
2237}

2239bool Method::is_method_id(jmethodID mid) {
Method* m = resolve_jmethod_id(mid);
assert(m != NULL, "should be called with non-null method")do { if (!(m != __null)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2241, "assert(" "m != __null" ") failed", "should be called with non-null method"
); ::breakpoint(); } } while (0);
InstanceKlass* ik = m->method_holder();
ClassLoaderData* cld = ik->class_loader_data();
if (cld->jmethod_ids() == NULL__null) return false;
return (cld->jmethod_ids()->contains((Method**)mid));
2246}

2248Method* Method::checked_resolve_jmethod_id(jmethodID mid) {
if (mid == NULL__null) return NULL__null;
Method* o = resolve_jmethod_id(mid);
if (o == NULL__null || o == JNIMethodBlock::_free_method) {
  return NULL__null;
}
// Method should otherwise be valid. Assert for testing.
assert(is_valid_method(o), "should be valid jmethodid")do { if (!(is_valid_method(o))) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2255, "assert(" "is_valid_method(o)" ") failed", "should be valid jmethodid"
); ::breakpoint(); } } while (0);
// If the method's class holder object is unreferenced, but not yet marked as
// unloaded, we need to return NULL here too because after a safepoint, its memory
// will be reclaimed.
return o->method_holder()->is_loader_alive() ? o : NULL__null;
2260};

2262void Method::set_on_stack(const bool value) {
// Set both the method itself and its constant pool.  The constant pool
// on stack means some method referring to it is also on the stack.
constants()->set_on_stack(value);

bool already_set = on_stack();
_access_flags.set_on_stack(value);
if (value && !already_set) {
  MetadataOnStackMark::record(this);
}
2272}

2274// Called when the class loader is unloaded to make all methods weak.
2275void Method::clear_jmethod_ids(ClassLoaderData* loader_data) {
loader_data->jmethod_ids()->clear_all_methods();
2277}

2279bool Method::has_method_vptr(const void* ptr) {
Method m;
// This assumes that the vtbl pointer is the first word of a C++ object.
return dereference_vptr(&m) == dereference_vptr(ptr);
10
←
Calling 'dereference_vptr'→
2283}

2285// Check that this pointer is valid by checking that the vtbl pointer matches
2286bool Method::is_valid_method(const Method* m) {
if (m2.1
'm' is not equal to NULL
1
'm' is not equal to NULL
 == NULL__null) {
3
←
Taking false branch→
  return false;
} else if ((intptr_t(m) & (wordSize-1)) != 0) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
  // Quick sanity check on pointer.
  return false;
} else if (m->is_shared()) {
6
←
Taking false branch→
  return CppVtables::is_valid_shared_method(m);
} else if (Metaspace::contains_non_shared(m)) {
7
←
Assuming the condition is true→
8
←
Taking true branch→
  return has_method_vptr((const void*)m);
9
←
Calling 'Method::has_method_vptr'→
} else {
  return false;
}
2299}

2301#ifndef PRODUCT
2302void Method::print_jmethod_ids_count(const ClassLoaderData* loader_data, outputStream* out) {
out->print("%d", loader_data->jmethod_ids()->count_methods());
2304}
2305#endif // PRODUCT


2308// Printing

2310#ifndef PRODUCT

2312void Method::print_on(outputStream* st) const {
ResourceMark rm;
assert(is_method(), "must be method")do { if (!(is_method())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2314, "assert(" "is_method()" ") failed", "must be method")
; ::breakpoint(); } } while (0);
st->print_cr("%s", internal_name());
st->print_cr(" - this oop:          " INTPTR_FORMAT"0x%016" "l" "x", p2i(this));
st->print   (" - method holder:     "); method_holder()->print_value_on(st); st->cr();
st->print   (" - constants:         " INTPTR_FORMAT"0x%016" "l" "x" " ", p2i(constants()));
constants()->print_value_on(st); st->cr();
st->print   (" - access:            0x%x  ", access_flags().as_int()); access_flags().print_on(st); st->cr();
st->print   (" - name:              ");    name()->print_value_on(st); st->cr();
st->print   (" - signature:         ");    signature()->print_value_on(st); st->cr();
st->print_cr(" - max stack:         %d",   max_stack());
st->print_cr(" - max locals:        %d",   max_locals());
st->print_cr(" - size of params:    %d",   size_of_parameters());
st->print_cr(" - method size:       %d",   method_size());
if (intrinsic_id() != vmIntrinsics::_none)
  st->print_cr(" - intrinsic id:      %d %s", vmIntrinsics::as_int(intrinsic_id()), vmIntrinsics::name_at(intrinsic_id()));
if (highest_comp_level() != CompLevel_none)
  st->print_cr(" - highest level:     %d", highest_comp_level());
st->print_cr(" - vtable index:      %d",   _vtable_index);
st->print_cr(" - i2i entry:         " INTPTR_FORMAT"0x%016" "l" "x", p2i(interpreter_entry()));
st->print(   " - adapters:          ");
AdapterHandlerEntry* a = ((Method*)this)->adapter();
if (a == NULL__null)
  st->print_cr(INTPTR_FORMAT"0x%016" "l" "x", p2i(a));
else
  a->print_adapter_on(st);
st->print_cr(" - compiled entry     " INTPTR_FORMAT"0x%016" "l" "x", p2i(from_compiled_entry()));
st->print_cr(" - code size:         %d",   code_size());
if (code_size() != 0) {
  st->print_cr(" - code start:        " INTPTR_FORMAT"0x%016" "l" "x", p2i(code_base()));
  st->print_cr(" - code end (excl):   " INTPTR_FORMAT"0x%016" "l" "x", p2i(code_base() + code_size()));
}
if (method_data() != NULL__null) {
  st->print_cr(" - method data:       " INTPTR_FORMAT"0x%016" "l" "x", p2i(method_data()));
}
st->print_cr(" - checked ex length: %d",   checked_exceptions_length());
if (checked_exceptions_length() > 0) {
  CheckedExceptionElement* table = checked_exceptions_start();
  st->print_cr(" - checked ex start:  " INTPTR_FORMAT"0x%016" "l" "x", p2i(table));
  if (Verbose) {
    for (int i = 0; i < checked_exceptions_length(); i++) {
      st->print_cr("   - throws %s", constants()->printable_name_at(table[i].class_cp_index));
    }
  }
}
if (has_linenumber_table()) {
  u_char* table = compressed_linenumber_table();
  st->print_cr(" - linenumber start:  " INTPTR_FORMAT"0x%016" "l" "x", p2i(table));
  if (Verbose) {
    CompressedLineNumberReadStream stream(table);
    while (stream.read_pair()) {
      st->print_cr("   - line %d: %d", stream.line(), stream.bci());
    }
  }
}
st->print_cr(" - localvar length:   %d",   localvariable_table_length());
if (localvariable_table_length() > 0) {
  LocalVariableTableElement* table = localvariable_table_start();
  st->print_cr(" - localvar start:    " INTPTR_FORMAT"0x%016" "l" "x", p2i(table));
  if (Verbose) {
    for (int i = 0; i < localvariable_table_length(); i++) {
      int bci = table[i].start_bci;
      int len = table[i].length;
      const char* name = constants()->printable_name_at(table[i].name_cp_index);
      const char* desc = constants()->printable_name_at(table[i].descriptor_cp_index);
      int slot = table[i].slot;
      st->print_cr("   - %s %s bci=%d len=%d slot=%d", desc, name, bci, len, slot);
    }
  }
}
if (code() != NULL__null) {
  st->print   (" - compiled code: ");
  code()->print_value_on(st);
}
if (is_native()) {
  st->print_cr(" - native function:   " INTPTR_FORMAT"0x%016" "l" "x", p2i(native_function()));
  st->print_cr(" - signature handler: " INTPTR_FORMAT"0x%016" "l" "x", p2i(signature_handler()));
}
2391}

2393void Method::print_linkage_flags(outputStream* st) {
access_flags().print_on(st);
if (is_default_method()) {
  st->print("default ");
}
if (is_overpass()) {
  st->print("overpass ");
}
2401}
2402#endif //PRODUCT

2404void Method::print_value_on(outputStream* st) const {
assert(is_method(), "must be method")do { if (!(is_method())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2405, "assert(" "is_method()" ") failed", "must be method")
; ::breakpoint(); } } while (0);
st->print("%s", internal_name());
print_address_on(st);
st->print(" ");
name()->print_value_on(st);
st->print(" ");
signature()->print_value_on(st);
st->print(" in ");
method_holder()->print_value_on(st);
if (WizardMode) st->print("#%d", _vtable_index);
if (WizardMode) st->print("[%d,%d]", size_of_parameters(), max_locals());
if (WizardMode && code() != NULL__null) st->print(" ((nmethod*)%p)", code());
2417}

2419// LogTouchedMethods and PrintTouchedMethods

2421// TouchedMethodRecord -- we can't use a HashtableEntry<Method*> because
2422// the Method may be garbage collected. Let's roll our own hash table.
2423class TouchedMethodRecord : CHeapObj<mtTracing> {
2424public:
// It's OK to store Symbols here because they will NOT be GC'ed if
// LogTouchedMethods is enabled.
TouchedMethodRecord* _next;
Symbol* _class_name;
Symbol* _method_name;
Symbol* _method_signature;
2431};

2433static const int TOUCHED_METHOD_TABLE_SIZE = 20011;
2434static TouchedMethodRecord** _touched_method_table = NULL__null;

2436void Method::log_touched(Thread* current) {

const int table_size = TOUCHED_METHOD_TABLE_SIZE;
Symbol* my_class = klass_name();
Symbol* my_name  = name();
Symbol* my_sig   = signature();

unsigned int hash = my_class->identity_hash() +
                    my_name->identity_hash() +
                    my_sig->identity_hash();
juint index = juint(hash) % table_size;

MutexLocker ml(current, TouchedMethodLog_lock);
if (_touched_method_table == NULL__null) {
  _touched_method_table = NEW_C_HEAP_ARRAY2(TouchedMethodRecord*, table_size,(TouchedMethodRecord**) (AllocateHeap((table_size) * sizeof(TouchedMethodRecord
*), mtTracing, ((MemTracker::tracking_level() == NMT_detail) ?
 NativeCallStack(0) : NativeCallStack::empty_stack())))
                                            mtTracing, CURRENT_PC)(TouchedMethodRecord**) (AllocateHeap((table_size) * sizeof(TouchedMethodRecord
*), mtTracing, ((MemTracker::tracking_level() == NMT_detail) ?
 NativeCallStack(0) : NativeCallStack::empty_stack())));
  memset(_touched_method_table, 0, sizeof(TouchedMethodRecord*)*table_size);
}

TouchedMethodRecord* ptr = _touched_method_table[index];
while (ptr) {
  if (ptr->_class_name       == my_class &&
      ptr->_method_name      == my_name &&
      ptr->_method_signature == my_sig) {
    return;
  }
  if (ptr->_next == NULL__null) break;
  ptr = ptr->_next;
}
TouchedMethodRecord* nptr = NEW_C_HEAP_OBJ(TouchedMethodRecord, mtTracing)(TouchedMethodRecord*) (AllocateHeap((1) * sizeof(TouchedMethodRecord
), mtTracing));
my_class->increment_refcount();
my_name->increment_refcount();
my_sig->increment_refcount();
nptr->_class_name         = my_class;
nptr->_method_name        = my_name;
nptr->_method_signature   = my_sig;
nptr->_next               = NULL__null;

if (ptr == NULL__null) {
  // first
  _touched_method_table[index] = nptr;
} else {
  ptr->_next = nptr;
}
2480}

2482void Method::print_touched_methods(outputStream* out) {
MutexLocker ml(Thread::current()->is_VM_thread() ? NULL__null : TouchedMethodLog_lock);
out->print_cr("# Method::print_touched_methods version 1");
if (_touched_method_table) {
  for (int i = 0; i < TOUCHED_METHOD_TABLE_SIZE; i++) {
    TouchedMethodRecord* ptr = _touched_method_table[i];
    while(ptr) {
      ptr->_class_name->print_symbol_on(out);       out->print(".");
      ptr->_method_name->print_symbol_on(out);      out->print(":");
      ptr->_method_signature->print_symbol_on(out); out->cr();
      ptr = ptr->_next;
    }
  }
}
2496}

2498// Verification

2500void Method::verify_on(outputStream* st) {
guarantee(is_method(), "object must be method")do { if (!(is_method())) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2501, "guarantee(" "is_method()" ") failed", "object must be method"
); ::breakpoint(); } } while (0);
guarantee(constants()->is_constantPool(), "should be constant pool")do { if (!(constants()->is_constantPool())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2502, "guarantee(" "constants()->is_constantPool()" ") failed"
, "should be constant pool"); ::breakpoint(); } } while (0);
MethodData* md = method_data();
guarantee(md == NULL ||do { if (!(md == __null || md->is_methodData())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2505, "guarantee(" "md == NULL || md->is_methodData()" ") failed"
, "should be method data"); ::breakpoint(); } } while (0)
    md->is_methodData(), "should be method data")do { if (!(md == __null || md->is_methodData())) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/oops/method.cpp"
, 2505, "guarantee(" "md == NULL || md->is_methodData()" ") failed"
, "should be method data"); ::breakpoint(); } } while (0);
2506}

←

/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp

1/*
2 * Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24 
25#ifndef SHARE_UTILITIES_GLOBALDEFINITIONS_HPP
26#define SHARE_UTILITIES_GLOBALDEFINITIONS_HPP
27 
28#include "utilities/compilerWarnings.hpp"
29#include "utilities/debug.hpp"
30#include "utilities/macros.hpp"
31 
32// Get constants like JVM_T_CHAR and JVM_SIGNATURE_INT, before pulling in <jvm.h>.
33#include "classfile_constants.h"
34 
35#include COMPILER_HEADER(utilities/globalDefinitions)"utilities/globalDefinitions_gcc.hpp"
36 
37#include <cstddef>
38 
39class oopDesc;
40 
41// Defaults for macros that might be defined per compiler.
42#ifndef NOINLINE__attribute__ ((noinline))
43#define NOINLINE__attribute__ ((noinline))
44#endif
45#ifndef ALWAYSINLINEinline __attribute__ ((always_inline))
46#define ALWAYSINLINEinline __attribute__ ((always_inline)) inline
47#endif
48 
49#ifndef ATTRIBUTE_ALIGNED
50#define ATTRIBUTE_ALIGNED(x)__attribute__((aligned(x)))
51#endif
52 
53#ifndef ATTRIBUTE_FLATTEN__attribute__ ((flatten))
54#define ATTRIBUTE_FLATTEN__attribute__ ((flatten))
55#endif
56 
57// These are #defines to selectively turn on/off the Print(Opto)Assembly
58// capabilities. Choices should be led by a tradeoff between
59// code size and improved supportability.
60// if PRINT_ASSEMBLY then PRINT_ABSTRACT_ASSEMBLY must be true as well
61// to have a fallback in case hsdis is not available.
62#if defined(PRODUCT)
63  #define SUPPORT_ABSTRACT_ASSEMBLY
64  #define SUPPORT_ASSEMBLY
65  #undef  SUPPORT_OPTO_ASSEMBLY      // Can't activate. In PRODUCT, many dump methods are missing.
66  #undef  SUPPORT_DATA_STRUCTS       // Of limited use. In PRODUCT, many print methods are empty.
67#else
68  #define SUPPORT_ABSTRACT_ASSEMBLY
69  #define SUPPORT_ASSEMBLY
70  #define SUPPORT_OPTO_ASSEMBLY
71  #define SUPPORT_DATA_STRUCTS
72#endif
73#if defined(SUPPORT_ASSEMBLY) && !defined(SUPPORT_ABSTRACT_ASSEMBLY)
74  #define SUPPORT_ABSTRACT_ASSEMBLY
75#endif
76 
77// This file holds all globally used constants & types, class (forward)
78// declarations and a few frequently used utility functions.
79 
80// Declare the named class to be noncopyable.  This macro must be followed by
81// a semi-colon.  The macro provides deleted declarations for the class's copy
82// constructor and assignment operator.  Because these operations are deleted,
83// they cannot be defined and potential callers will fail to compile.
84#define NONCOPYABLE(C)C(C const&) = delete; C& operator=(C const&) = delete C(C const&) = delete; C& operator=(C const&) = delete /* next token must be ; */
85 
86 
87//----------------------------------------------------------------------------------------------------
88// Printf-style formatters for fixed- and variable-width types as pointers and
89// integers.  These are derived from the definitions in inttypes.h.  If the platform
90// doesn't provide appropriate definitions, they should be provided in
91// the compiler-specific definitions file (e.g., globalDefinitions_gcc.hpp)
92 
93#define BOOL_TO_STR(_b_)((_b_) ? "true" : "false") ((_b_) ? "true" : "false")
94 
95// Format 32-bit quantities.
96#define INT32_FORMAT"%" "d"           "%" PRId32"d"
97#define UINT32_FORMAT"%" "u"          "%" PRIu32"u"
98#define INT32_FORMAT_W(width)"%" "width" "d"  "%" #width PRId32"d"
99#define UINT32_FORMAT_W(width)"%" "width" "u" "%" #width PRIu32"u"
100 
101#define PTR32_FORMAT"0x%08" "x"           "0x%08" PRIx32"x"
102#define PTR32_FORMAT_W(width)"0x%" "width" "x"  "0x%" #width PRIx32"x"
103 
104// Format 64-bit quantities.
105#define INT64_FORMAT"%" "l" "d"           "%" PRId64"l" "d"
106#define UINT64_FORMAT"%" "l" "u"          "%" PRIu64"l" "u"
107#define UINT64_FORMAT_X"%" "l" "x"        "%" PRIx64"l" "x"
108#define INT64_FORMAT_W(width)"%" "width" "l" "d"  "%" #width PRId64"l" "d"
109#define UINT64_FORMAT_W(width)"%" "width" "l" "u" "%" #width PRIu64"l" "u"
110#define UINT64_FORMAT_X_W(width)"%" "width" "l" "x" "%" #width PRIx64"l" "x"
111 
112#define PTR64_FORMAT"0x%016" "l" "x"           "0x%016" PRIx64"l" "x"
113 
114// Format jlong, if necessary
115#ifndef JLONG_FORMAT"%" "l" "d"
116#define JLONG_FORMAT"%" "l" "d"           INT64_FORMAT"%" "l" "d"
117#endif
118#ifndef JLONG_FORMAT_W
119#define JLONG_FORMAT_W(width)"%" "width" "l" "d"  INT64_FORMAT_W(width)"%" "width" "l" "d"
120#endif
121#ifndef JULONG_FORMAT"%" "l" "u"
122#define JULONG_FORMAT"%" "l" "u"          UINT64_FORMAT"%" "l" "u"
123#endif
124#ifndef JULONG_FORMAT_X"%" "l" "x"
125#define JULONG_FORMAT_X"%" "l" "x"        UINT64_FORMAT_X"%" "l" "x"
126#endif
127 
128// Format pointers which change size between 32- and 64-bit.
129#ifdef  _LP641
130#define INTPTR_FORMAT"0x%016" "l" "x" "0x%016" PRIxPTR"l" "x"
131#define PTR_FORMAT"0x%016" "l" "x"    "0x%016" PRIxPTR"l" "x"
132#else   // !_LP64
133#define INTPTR_FORMAT"0x%016" "l" "x" "0x%08"  PRIxPTR"l" "x"
134#define PTR_FORMAT"0x%016" "l" "x"    "0x%08"  PRIxPTR"l" "x"
135#endif  // _LP64
136 
137// Format pointers without leading zeros
138#define INTPTRNZ_FORMAT"0x%" "l" "x" "0x%"  PRIxPTR"l" "x"
139 
140#define INTPTR_FORMAT_W(width)"%" "width" "l" "x"   "%" #width PRIxPTR"l" "x"
141 
142#define SSIZE_FORMAT"%" "l" "d"             "%"   PRIdPTR"l" "d"
143#define SIZE_FORMAT"%" "l" "u"              "%"   PRIuPTR"l" "u"
144#define SIZE_FORMAT_HEX"0x%" "l" "x"          "0x%" PRIxPTR"l" "x"
145#define SSIZE_FORMAT_W(width)"%" "width" "l" "d"    "%"   #width PRIdPTR"l" "d"
146#define SIZE_FORMAT_W(width)"%" "width" "l" "u"     "%"   #width PRIuPTR"l" "u"
147#define SIZE_FORMAT_HEX_W(width)"0x%" "width" "l" "x" "0x%" #width PRIxPTR"l" "x"
148 
149#define INTX_FORMAT"%" "l" "d"           "%" PRIdPTR"l" "d"
150#define UINTX_FORMAT"%" "l" "u"          "%" PRIuPTR"l" "u"
151#define INTX_FORMAT_W(width)"%" "width" "l" "d"  "%" #width PRIdPTR"l" "d"
152#define UINTX_FORMAT_W(width)"%" "width" "l" "u" "%" #width PRIuPTR"l" "u"
153 
154// Convert pointer to intptr_t, for use in printing pointers.
155inline intptr_t p2i(const volatile void* p) {
156  return (intptr_t) p;
157}
158 
159//----------------------------------------------------------------------------------------------------
160// Constants
161 
162const int LogBytesPerShort   = 1;
163const int LogBytesPerInt     = 2;
164#ifdef _LP641
165const int LogBytesPerWord    = 3;
166#else
167const int LogBytesPerWord    = 2;
168#endif
169const int LogBytesPerLong    = 3;
170 
171const int BytesPerShort      = 1 << LogBytesPerShort;
172const int BytesPerInt        = 1 << LogBytesPerInt;
173const int BytesPerWord       = 1 << LogBytesPerWord;
174const int BytesPerLong       = 1 << LogBytesPerLong;
175 
176const int LogBitsPerByte     = 3;
177const int LogBitsPerShort    = LogBitsPerByte + LogBytesPerShort;
178const int LogBitsPerInt      = LogBitsPerByte + LogBytesPerInt;
179const int LogBitsPerWord     = LogBitsPerByte + LogBytesPerWord;
180const int LogBitsPerLong     = LogBitsPerByte + LogBytesPerLong;
181 
182const int BitsPerByte        = 1 << LogBitsPerByte;
183const int BitsPerShort       = 1 << LogBitsPerShort;
184const int BitsPerInt         = 1 << LogBitsPerInt;
185const int BitsPerWord        = 1 << LogBitsPerWord;
186const int BitsPerLong        = 1 << LogBitsPerLong;
187 
188const int WordAlignmentMask  = (1 << LogBytesPerWord) - 1;
189const int LongAlignmentMask  = (1 << LogBytesPerLong) - 1;
190 
191const int WordsPerLong       = 2;       // Number of stack entries for longs
192 
193const int oopSize            = sizeof(char*); // Full-width oop
194extern int heapOopSize;                       // Oop within a java object
195const int wordSize           = sizeof(char*);
196const int longSize           = sizeof(jlong);
197const int jintSize           = sizeof(jint);
198const int size_tSize         = sizeof(size_t);
199 
200const int BytesPerOop        = BytesPerWord;  // Full-width oop
201 
202extern int LogBytesPerHeapOop;                // Oop within a java object
203extern int LogBitsPerHeapOop;
204extern int BytesPerHeapOop;
205extern int BitsPerHeapOop;
206 
207const int BitsPerJavaInteger = 32;
208const int BitsPerJavaLong    = 64;
209const int BitsPerSize_t      = size_tSize * BitsPerByte;
210 
211// Size of a char[] needed to represent a jint as a string in decimal.
212const int jintAsStringSize = 12;
213 
214// An opaque type, so that HeapWord* can be a generic pointer into the heap.
215// We require that object sizes be measured in units of heap words (e.g.
216// pointer-sized values), so that given HeapWord* hw,
217//   hw += oop(hw)->foo();
218// works, where foo is a method (like size or scavenge) that returns the
219// object size.
220class HeapWordImpl;             // Opaque, never defined.
221typedef HeapWordImpl* HeapWord;
222 
223// Analogous opaque struct for metadata allocated from metaspaces.
224class MetaWordImpl;             // Opaque, never defined.
225typedef MetaWordImpl* MetaWord;
226 
227// HeapWordSize must be 2^LogHeapWordSize.
228const int HeapWordSize        = sizeof(HeapWord);
229#ifdef _LP641
230const int LogHeapWordSize     = 3;
231#else
232const int LogHeapWordSize     = 2;
233#endif
234const int HeapWordsPerLong    = BytesPerLong / HeapWordSize;
235const int LogHeapWordsPerLong = LogBytesPerLong - LogHeapWordSize;
236 
237// The minimum number of native machine words necessary to contain "byte_size"
238// bytes.
239inline size_t heap_word_size(size_t byte_size) {
240  return (byte_size + (HeapWordSize-1)) >> LogHeapWordSize;
241}
242 
243inline jfloat jfloat_cast(jint x);
244inline jdouble jdouble_cast(jlong x);
245 
246//-------------------------------------------
247// Constant for jlong (standardized by C++11)
248 
249// Build a 64bit integer constant
250#define CONST64(x)(xLL)  (x ## LL)
251#define UCONST64(x)(xULL) (x ## ULL)
252 
253const jlong min_jlong = CONST64(0x8000000000000000)(0x8000000000000000LL);
254const jlong max_jlong = CONST64(0x7fffffffffffffff)(0x7fffffffffffffffLL);
255 
256//-------------------------------------------
257// Constant for jdouble
258const jlong min_jlongDouble = CONST64(0x0000000000000001)(0x0000000000000001LL);
259const jdouble min_jdouble = jdouble_cast(min_jlongDouble);
260const jlong max_jlongDouble = CONST64(0x7fefffffffffffff)(0x7fefffffffffffffLL);
261const jdouble max_jdouble = jdouble_cast(max_jlongDouble);
262 
263const size_t K                  = 1024;
264const size_t M                  = K*K;
265const size_t G                  = M*K;
266const size_t HWperKB            = K / sizeof(HeapWord);
267 
268// Constants for converting from a base unit to milli-base units.  For
269// example from seconds to milliseconds and microseconds
270 
271const int MILLIUNITS    = 1000;         // milli units per base unit
272const int MICROUNITS    = 1000000;      // micro units per base unit
273const int NANOUNITS     = 1000000000;   // nano units per base unit
274const int NANOUNITS_PER_MILLIUNIT = NANOUNITS / MILLIUNITS;
275 
276const jlong NANOSECS_PER_SEC      = CONST64(1000000000)(1000000000LL);
277const jint  NANOSECS_PER_MILLISEC = 1000000;
278 
279 
280// Unit conversion functions
281// The caller is responsible for considering overlow.
282 
283inline int64_t nanos_to_millis(int64_t nanos) {
284  return nanos / NANOUNITS_PER_MILLIUNIT;
285}
286inline int64_t millis_to_nanos(int64_t millis) {
287  return millis * NANOUNITS_PER_MILLIUNIT;
288}
289 
290// Proper units routines try to maintain at least three significant digits.
291// In worst case, it would print five significant digits with lower prefix.
292// G is close to MAX_SIZE on 32-bit platforms, so its product can easily overflow,
293// and therefore we need to be careful.
294 
295inline const char* proper_unit_for_byte_size(size_t s) {
296#ifdef _LP641
297  if (s >= 100*G) {
298    return "G";
299  }
300#endif
301  if (s >= 100*M) {
302    return "M";
303  } else if (s >= 100*K) {
304    return "K";
305  } else {
306    return "B";
307  }
308}
309 
310template <class T>
311inline T byte_size_in_proper_unit(T s) {
312#ifdef _LP641
313  if (s >= 100*G) {
314    return (T)(s/G);
315  }
316#endif
317  if (s >= 100*M) {
318    return (T)(s/M);
319  } else if (s >= 100*K) {
320    return (T)(s/K);
321  } else {
322    return s;
323  }
324}
325 
326inline const char* exact_unit_for_byte_size(size_t s) {
327#ifdef _LP641
328  if (s >= G && (s % G) == 0) {
329    return "G";
330  }
331#endif
332  if (s >= M && (s % M) == 0) {
333    return "M";
334  }
335  if (s >= K && (s % K) == 0) {
336    return "K";
337  }
338  return "B";
339}
340 
341inline size_t byte_size_in_exact_unit(size_t s) {
342#ifdef _LP641
343  if (s >= G && (s % G) == 0) {
344    return s / G;
345  }
346#endif
347  if (s >= M && (s % M) == 0) {
348    return s / M;
349  }
350  if (s >= K && (s % K) == 0) {
351    return s / K;
352  }
353  return s;
354}
355 
356// Memory size transition formatting.
357 
358#define HEAP_CHANGE_FORMAT"%s: " "%" "l" "u" "K(" "%" "l" "u" "K)->" "%" "l" "u" "K("
 "%" "l" "u" "K)" "%s: " SIZE_FORMAT"%" "l" "u" "K(" SIZE_FORMAT"%" "l" "u" "K)->" SIZE_FORMAT"%" "l" "u" "K(" SIZE_FORMAT"%" "l" "u" "K)"
359 
360#define HEAP_CHANGE_FORMAT_ARGS(_name_, _prev_used_, _prev_capacity_, _used_, _capacity_)(_name_), (_prev_used_) / K, (_prev_capacity_) / K, (_used_) /
 K, (_capacity_) / K \
361  (_name_), (_prev_used_) / K, (_prev_capacity_) / K, (_used_) / K, (_capacity_) / K
362 
363//----------------------------------------------------------------------------------------------------
364// VM type definitions
365 
366// intx and uintx are the 'extended' int and 'extended' unsigned int types;
367// they are 32bit wide on a 32-bit platform, and 64bit wide on a 64bit platform.
368 
369typedef intptr_t  intx;
370typedef uintptr_t uintx;
371 
372const intx  min_intx  = (intx)1 << (sizeof(intx)*BitsPerByte-1);
373const intx  max_intx  = (uintx)min_intx - 1;
374const uintx max_uintx = (uintx)-1;
375 
376// Table of values:
377//      sizeof intx         4               8
378// min_intx             0x80000000      0x8000000000000000
379// max_intx             0x7FFFFFFF      0x7FFFFFFFFFFFFFFF
380// max_uintx            0xFFFFFFFF      0xFFFFFFFFFFFFFFFF
381 
382typedef unsigned int uint;   NEEDS_CLEANUP
383 
384 
385//----------------------------------------------------------------------------------------------------
386// Java type definitions
387 
388// All kinds of 'plain' byte addresses
389typedef   signed char s_char;
390typedef unsigned char u_char;
391typedef u_char*       address;
392typedef uintptr_t     address_word; // unsigned integer which will hold a pointer
393                                    // except for some implementations of a C++
394                                    // linkage pointer to function. Should never
395                                    // need one of those to be placed in this
396                                    // type anyway.
397 
398//  Utility functions to "portably" (?) bit twiddle pointers
399//  Where portable means keep ANSI C++ compilers quiet
400 
401inline address       set_address_bits(address x, int m)       { return address(intptr_t(x) | m); }
402inline address       clear_address_bits(address x, int m)     { return address(intptr_t(x) & ~m); }
403 
404//  Utility functions to "portably" make cast to/from function pointers.
405 
406inline address_word  mask_address_bits(address x, int m)      { return address_word(x) & m; }
407inline address_word  castable_address(address x)              { return address_word(x) ; }
408inline address_word  castable_address(void* x)                { return address_word(x) ; }
409 
410// Pointer subtraction.
411// The idea here is to avoid ptrdiff_t, which is signed and so doesn't have
412// the range we might need to find differences from one end of the heap
413// to the other.
414// A typical use might be:
415//     if (pointer_delta(end(), top()) >= size) {
416//       // enough room for an object of size
417//       ...
418// and then additions like
419//       ... top() + size ...
420// are safe because we know that top() is at least size below end().
421inline size_t pointer_delta(const volatile void* left,
422                            const volatile void* right,
423                            size_t element_size) {
424  assert(left >= right, "avoid underflow - left: " PTR_FORMAT " right: " PTR_FORMAT, p2i(left), p2i(right))do { if (!(left >= right)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp"
, 424, "assert(" "left >= right" ") failed", "avoid underflow - left: "
 "0x%016" "l" "x" " right: " "0x%016" "l" "x", p2i(left), p2i
(right)); ::breakpoint(); } } while (0);
425  return (((uintptr_t) left) - ((uintptr_t) right)) / element_size;
426}
427 
428// A version specialized for HeapWord*'s.
429inline size_t pointer_delta(const HeapWord* left, const HeapWord* right) {
430  return pointer_delta(left, right, sizeof(HeapWord));
431}
432// A version specialized for MetaWord*'s.
433inline size_t pointer_delta(const MetaWord* left, const MetaWord* right) {
434  return pointer_delta(left, right, sizeof(MetaWord));
435}
436 
437//
438// ANSI C++ does not allow casting from one pointer type to a function pointer
439// directly without at best a warning. This macro accomplishes it silently
440// In every case that is present at this point the value be cast is a pointer
441// to a C linkage function. In some case the type used for the cast reflects
442// that linkage and a picky compiler would not complain. In other cases because
443// there is no convenient place to place a typedef with extern C linkage (i.e
444// a platform dependent header file) it doesn't. At this point no compiler seems
445// picky enough to catch these instances (which are few). It is possible that
446// using templates could fix these for all cases. This use of templates is likely
447// so far from the middle of the road that it is likely to be problematic in
448// many C++ compilers.
449//
450#define CAST_TO_FN_PTR(func_type, value)(reinterpret_cast<func_type>(value)) (reinterpret_cast<func_type>(value))
451#define CAST_FROM_FN_PTR(new_type, func_ptr)((new_type)((address_word)(func_ptr))) ((new_type)((address_word)(func_ptr)))
452 
453// In many places we've added C-style casts to silence compiler
454// warnings, for example when truncating a size_t to an int when we
455// know the size_t is a small struct. Such casts are risky because
456// they effectively disable useful compiler warnings. We can make our
457// lives safer with this function, which ensures that any cast is
458// reversible without loss of information. It doesn't check
459// everything: it isn't intended to make sure that pointer types are
460// compatible, for example.
461template <typename T2, typename T1>
462T2 checked_cast(T1 thing) {
463  T2 result = static_cast<T2>(thing);
464  assert(static_cast<T1>(result) == thing, "must be")do { if (!(static_cast<T1>(result) == thing)) { (*g_assert_poison
) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp"
, 464, "assert(" "static_cast<T1>(result) == thing" ") failed"
, "must be"); ::breakpoint(); } } while (0);
465  return result;
466}
467 
468// Need the correct linkage to call qsort without warnings
469extern "C" {
470  typedef int (*_sort_Fn)(const void *, const void *);
471}
472 
473// Unsigned byte types for os and stream.hpp
474 
475// Unsigned one, two, four and eigth byte quantities used for describing
476// the .class file format. See JVM book chapter 4.
477 
478typedef jubyte  u1;
479typedef jushort u2;
480typedef juint   u4;
481typedef julong  u8;
482 
483const jubyte  max_jubyte  = (jubyte)-1;  // 0xFF       largest jubyte
484const jushort max_jushort = (jushort)-1; // 0xFFFF     largest jushort
485const juint   max_juint   = (juint)-1;   // 0xFFFFFFFF largest juint
486const julong  max_julong  = (julong)-1;  // 0xFF....FF largest julong
487 
488typedef jbyte  s1;
489typedef jshort s2;
490typedef jint   s4;
491typedef jlong  s8;
492 
493const jbyte min_jbyte = -(1 << 7);       // smallest jbyte
494const jbyte max_jbyte = (1 << 7) - 1;    // largest jbyte
495const jshort min_jshort = -(1 << 15);    // smallest jshort
496const jshort max_jshort = (1 << 15) - 1; // largest jshort
497 
498const jint min_jint = (jint)1 << (sizeof(jint)*BitsPerByte-1); // 0x80000000 == smallest jint
499const jint max_jint = (juint)min_jint - 1;                     // 0x7FFFFFFF == largest jint
500 
501const jint min_jintFloat = (jint)(0x00000001);
502const jfloat min_jfloat = jfloat_cast(min_jintFloat);
503const jint max_jintFloat = (jint)(0x7f7fffff);
504const jfloat max_jfloat = jfloat_cast(max_jintFloat);
505 
506//----------------------------------------------------------------------------------------------------
507// JVM spec restrictions
508 
509const int max_method_code_size = 64*K - 1;  // JVM spec, 2nd ed. section 4.8.1 (p.134)
510 
511//----------------------------------------------------------------------------------------------------
512// old CDS options
513extern bool DumpSharedSpaces;
514extern bool DynamicDumpSharedSpaces;
515extern bool RequireSharedSpaces;
516extern "C" {
517// Make sure UseSharedSpaces is accessible to the serviceability agent.
518extern JNIEXPORT__attribute__((visibility("default"))) jboolean UseSharedSpaces;
519}
520 
521//----------------------------------------------------------------------------------------------------
522// Object alignment, in units of HeapWords.
523//
524// Minimum is max(BytesPerLong, BytesPerDouble, BytesPerOop) / HeapWordSize, so jlong, jdouble and
525// reference fields can be naturally aligned.
526 
527extern int MinObjAlignment;
528extern int MinObjAlignmentInBytes;
529extern int MinObjAlignmentInBytesMask;
530 
531extern int LogMinObjAlignment;
532extern int LogMinObjAlignmentInBytes;
533 
534const int LogKlassAlignmentInBytes = 3;
535const int LogKlassAlignment        = LogKlassAlignmentInBytes - LogHeapWordSize;
536const int KlassAlignmentInBytes    = 1 << LogKlassAlignmentInBytes;
537const int KlassAlignment           = KlassAlignmentInBytes / HeapWordSize;
538 
539// Maximal size of heap where unscaled compression can be used. Also upper bound
540// for heap placement: 4GB.
541const  uint64_t UnscaledOopHeapMax = (uint64_t(max_juint) + 1);
542// Maximal size of heap where compressed oops can be used. Also upper bound for heap
543// placement for zero based compression algorithm: UnscaledOopHeapMax << LogMinObjAlignmentInBytes.
544extern uint64_t OopEncodingHeapMax;
545 
546// Maximal size of compressed class space. Above this limit compression is not possible.
547// Also upper bound for placement of zero based class space. (Class space is further limited
548// to be < 3G, see arguments.cpp.)
549const  uint64_t KlassEncodingMetaspaceMax = (uint64_t(max_juint) + 1) << LogKlassAlignmentInBytes;
550 
551// Machine dependent stuff
552 
553// The maximum size of the code cache.  Can be overridden by targets.
554#define CODE_CACHE_SIZE_LIMIT(2*G) (2*G)
555// Allow targets to reduce the default size of the code cache.
556#define CODE_CACHE_DEFAULT_LIMIT(2*G) CODE_CACHE_SIZE_LIMIT(2*G)
557 
558#include CPU_HEADER(globalDefinitions)"globalDefinitions_x86.hpp"
559 
560// To assure the IRIW property on processors that are not multiple copy
561// atomic, sync instructions must be issued between volatile reads to
562// assure their ordering, instead of after volatile stores.
563// (See "A Tutorial Introduction to the ARM and POWER Relaxed Memory Models"
564// by Luc Maranget, Susmit Sarkar and Peter Sewell, INRIA/Cambridge)
565#ifdef CPU_MULTI_COPY_ATOMIC
566// Not needed.
567const bool support_IRIW_for_not_multiple_copy_atomic_cpu = false;
568#else
569// From all non-multi-copy-atomic architectures, only PPC64 supports IRIW at the moment.
570// Final decision is subject to JEP 188: Java Memory Model Update.
571const bool support_IRIW_for_not_multiple_copy_atomic_cpu = PPC64_ONLY(true) NOT_PPC64(false)false;
572#endif
573 
574// The expected size in bytes of a cache line, used to pad data structures.
575#ifndef DEFAULT_CACHE_LINE_SIZE128
576  #define DEFAULT_CACHE_LINE_SIZE128 64
577#endif
578 
579 
580//----------------------------------------------------------------------------------------------------
581// Utility macros for compilers
582// used to silence compiler warnings
583 
584#define Unused_Variable(var)var var
585 
586 
587//----------------------------------------------------------------------------------------------------
588// Miscellaneous
589 
590// 6302670 Eliminate Hotspot __fabsf dependency
591// All fabs() callers should call this function instead, which will implicitly
592// convert the operand to double, avoiding a dependency on __fabsf which
593// doesn't exist in early versions of Solaris 8.
594inline double fabsd(double value) {
595  return fabs(value);
596}
597 
598// Returns numerator/denominator as percentage value from 0 to 100. If denominator
599// is zero, return 0.0.
600template<typename T>
601inline double percent_of(T numerator, T denominator) {
602  return denominator != 0 ? (double)numerator / denominator * 100.0 : 0.0;
603}
604 
605//----------------------------------------------------------------------------------------------------
606// Special casts
607// Cast floats into same-size integers and vice-versa w/o changing bit-pattern
608typedef union {
609  jfloat f;
610  jint i;
611} FloatIntConv;
612 
613typedef union {
614  jdouble d;
615  jlong l;
616  julong ul;
617} DoubleLongConv;
618 
619inline jint    jint_cast    (jfloat  x)  { return ((FloatIntConv*)&x)->i; }
620inline jfloat  jfloat_cast  (jint    x)  { return ((FloatIntConv*)&x)->f; }
621 
622inline jlong   jlong_cast   (jdouble x)  { return ((DoubleLongConv*)&x)->l;  }
623inline julong  julong_cast  (jdouble x)  { return ((DoubleLongConv*)&x)->ul; }
624inline jdouble jdouble_cast (jlong   x)  { return ((DoubleLongConv*)&x)->d;  }
625 
626inline jint low (jlong value)                    { return jint(value); }
627inline jint high(jlong value)                    { return jint(value >> 32); }
628 
629// the fancy casts are a hopefully portable way
630// to do unsigned 32 to 64 bit type conversion
631inline void set_low (jlong* value, jint low )    { *value &= (jlong)0xffffffff << 32;
632                                                   *value |= (jlong)(julong)(juint)low; }
633 
634inline void set_high(jlong* value, jint high)    { *value &= (jlong)(julong)(juint)0xffffffff;
635                                                   *value |= (jlong)high       << 32; }
636 
637inline jlong jlong_from(jint h, jint l) {
638  jlong result = 0; // initialization to avoid warning
639  set_high(&result, h);
640  set_low(&result,  l);
641  return result;
642}
643 
644union jlong_accessor {
645  jint  words[2];
646  jlong long_value;
647};
648 
649void basic_types_init(); // cannot define here; uses assert
650 
651 
652// NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java
653enum BasicType {
654// The values T_BOOLEAN..T_LONG (4..11) are derived from the JVMS.
655  T_BOOLEAN     = JVM_T_BOOLEAN,
656  T_CHAR        = JVM_T_CHAR,
657  T_FLOAT       = JVM_T_FLOAT,
658  T_DOUBLE      = JVM_T_DOUBLE,
659  T_BYTE        = JVM_T_BYTE,
660  T_SHORT       = JVM_T_SHORT,
661  T_INT         = JVM_T_INT,
662  T_LONG        = JVM_T_LONG,
663  // The remaining values are not part of any standard.
664  // T_OBJECT and T_VOID denote two more semantic choices
665  // for method return values.
666  // T_OBJECT and T_ARRAY describe signature syntax.
667  // T_ADDRESS, T_METADATA, T_NARROWOOP, T_NARROWKLASS describe
668  // internal references within the JVM as if they were Java
669  // types in their own right.
670  T_OBJECT      = 12,
671  T_ARRAY       = 13,
672  T_VOID        = 14,
673  T_ADDRESS     = 15,
674  T_NARROWOOP   = 16,
675  T_METADATA    = 17,
676  T_NARROWKLASS = 18,
677  T_CONFLICT    = 19, // for stack value type with conflicting contents
678  T_ILLEGAL     = 99
679};
680 
681#define SIGNATURE_TYPES_DO(F, N)F(JVM_SIGNATURE_BOOLEAN, T_BOOLEAN, N) F(JVM_SIGNATURE_CHAR, T_CHAR
, N) F(JVM_SIGNATURE_FLOAT, T_FLOAT, N) F(JVM_SIGNATURE_DOUBLE
, T_DOUBLE, N) F(JVM_SIGNATURE_BYTE, T_BYTE, N) F(JVM_SIGNATURE_SHORT
, T_SHORT, N) F(JVM_SIGNATURE_INT, T_INT, N) F(JVM_SIGNATURE_LONG
, T_LONG, N) F(JVM_SIGNATURE_CLASS, T_OBJECT, N) F(JVM_SIGNATURE_ARRAY
, T_ARRAY, N) F(JVM_SIGNATURE_VOID, T_VOID, N)                \
682    F(JVM_SIGNATURE_BOOLEAN, T_BOOLEAN, N)      \
683    F(JVM_SIGNATURE_CHAR,    T_CHAR,    N)      \
684    F(JVM_SIGNATURE_FLOAT,   T_FLOAT,   N)      \
685    F(JVM_SIGNATURE_DOUBLE,  T_DOUBLE,  N)      \
686    F(JVM_SIGNATURE_BYTE,    T_BYTE,    N)      \
687    F(JVM_SIGNATURE_SHORT,   T_SHORT,   N)      \
688    F(JVM_SIGNATURE_INT,     T_INT,     N)      \
689    F(JVM_SIGNATURE_LONG,    T_LONG,    N)      \
690    F(JVM_SIGNATURE_CLASS,   T_OBJECT,  N)      \
691    F(JVM_SIGNATURE_ARRAY,   T_ARRAY,   N)      \
692    F(JVM_SIGNATURE_VOID,    T_VOID,    N)      \
693    /*end*/
694 
695inline bool is_java_type(BasicType t) {
696  return T_BOOLEAN <= t && t <= T_VOID;
697}
698 
699inline bool is_java_primitive(BasicType t) {
700  return T_BOOLEAN <= t && t <= T_LONG;
701}
702 
703inline bool is_subword_type(BasicType t) {
704  // these guys are processed exactly like T_INT in calling sequences:
705  return (t == T_BOOLEAN || t == T_CHAR || t == T_BYTE || t == T_SHORT);
706}
707 
708inline bool is_signed_subword_type(BasicType t) {
709  return (t == T_BYTE || t == T_SHORT);
710}
711 
712inline bool is_double_word_type(BasicType t) {
713  return (t == T_DOUBLE || t == T_LONG);
714}
715 
716inline bool is_reference_type(BasicType t) {
717  return (t == T_OBJECT || t == T_ARRAY);
718}
719 
720inline bool is_integral_type(BasicType t) {
721  return is_subword_type(t) || t == T_INT || t == T_LONG;
722}
723 
724inline bool is_floating_point_type(BasicType t) {
725  return (t == T_FLOAT || t == T_DOUBLE);
726}
727 
728extern char type2char_tab[T_CONFLICT+1];     // Map a BasicType to a jchar
729inline char type2char(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2char_tab[t] : 0; }
730extern int type2size[T_CONFLICT+1];         // Map BasicType to result stack elements
731extern const char* type2name_tab[T_CONFLICT+1];     // Map a BasicType to a jchar
732inline const char* type2name(BasicType t) { return (uint)t < T_CONFLICT+1 ? type2name_tab[t] : NULL__null; }
733extern BasicType name2type(const char* name);
734 
735inline jlong max_signed_integer(BasicType bt) {
736  if (bt == T_INT) {
737    return max_jint;
738  }
739  assert(bt == T_LONG, "unsupported")do { if (!(bt == T_LONG)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp"
, 739, "assert(" "bt == T_LONG" ") failed", "unsupported"); ::
breakpoint(); } } while (0);
740  return max_jlong;
741}
742 
743inline jlong min_signed_integer(BasicType bt) {
744  if (bt == T_INT) {
745    return min_jint;
746  }
747  assert(bt == T_LONG, "unsupported")do { if (!(bt == T_LONG)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp"
, 747, "assert(" "bt == T_LONG" ") failed", "unsupported"); ::
breakpoint(); } } while (0);
748  return min_jlong;
749}
750 
751// Auxiliary math routines
752// least common multiple
753extern size_t lcm(size_t a, size_t b);
754 
755 
756// NOTE: replicated in SA in vm/agent/sun/jvm/hotspot/runtime/BasicType.java
757enum BasicTypeSize {
758  T_BOOLEAN_size     = 1,
759  T_CHAR_size        = 1,
760  T_FLOAT_size       = 1,
761  T_DOUBLE_size      = 2,
762  T_BYTE_size        = 1,
763  T_SHORT_size       = 1,
764  T_INT_size         = 1,
765  T_LONG_size        = 2,
766  T_OBJECT_size      = 1,
767  T_ARRAY_size       = 1,
768  T_NARROWOOP_size   = 1,
769  T_NARROWKLASS_size = 1,
770  T_VOID_size        = 0
771};
772 
773// this works on valid parameter types but not T_VOID, T_CONFLICT, etc.
774inline int parameter_type_word_count(BasicType t) {
775  if (is_double_word_type(t))  return 2;
776  assert(is_java_primitive(t) || is_reference_type(t), "no goofy types here please")do { if (!(is_java_primitive(t) || is_reference_type(t))) { (
*g_assert_poison) = 'X';; report_vm_error("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp"
, 776, "assert(" "is_java_primitive(t) || is_reference_type(t)"
 ") failed", "no goofy types here please"); ::breakpoint(); }
 } while (0);
777  assert(type2size[t] == 1, "must be")do { if (!(type2size[t] == 1)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp"
, 777, "assert(" "type2size[t] == 1" ") failed", "must be"); ::
breakpoint(); } } while (0);
778  return 1;
779}
780 
781// maps a BasicType to its instance field storage type:
782// all sub-word integral types are widened to T_INT
783extern BasicType type2field[T_CONFLICT+1];
784extern BasicType type2wfield[T_CONFLICT+1];
785 
786 
787// size in bytes
788enum ArrayElementSize {
789  T_BOOLEAN_aelem_bytes     = 1,
790  T_CHAR_aelem_bytes        = 2,
791  T_FLOAT_aelem_bytes       = 4,
792  T_DOUBLE_aelem_bytes      = 8,
793  T_BYTE_aelem_bytes        = 1,
794  T_SHORT_aelem_bytes       = 2,
795  T_INT_aelem_bytes         = 4,
796  T_LONG_aelem_bytes        = 8,
797#ifdef _LP641
798  T_OBJECT_aelem_bytes      = 8,
799  T_ARRAY_aelem_bytes       = 8,
800#else
801  T_OBJECT_aelem_bytes      = 4,
802  T_ARRAY_aelem_bytes       = 4,
803#endif
804  T_NARROWOOP_aelem_bytes   = 4,
805  T_NARROWKLASS_aelem_bytes = 4,
806  T_VOID_aelem_bytes        = 0
807};
808 
809extern int _type2aelembytes[T_CONFLICT+1]; // maps a BasicType to nof bytes used by its array element
810#ifdef ASSERT1
811extern int type2aelembytes(BasicType t, bool allow_address = false); // asserts
812#else
813inline int type2aelembytes(BasicType t, bool allow_address = false) { return _type2aelembytes[t]; }
814#endif
815 
816 
817// JavaValue serves as a container for arbitrary Java values.
818 
819class JavaValue {
820 
821 public:
822  typedef union JavaCallValue {
823    jfloat   f;
824    jdouble  d;
825    jint     i;
826    jlong    l;
827    jobject  h;
828    oopDesc* o;
829  } JavaCallValue;
830 
831 private:
832  BasicType _type;
833  JavaCallValue _value;
834 
835 public:
836  JavaValue(BasicType t = T_ILLEGAL) { _type = t; }
837 
838  JavaValue(jfloat value) {
839    _type    = T_FLOAT;
840    _value.f = value;
841  }
842 
843  JavaValue(jdouble value) {
844    _type    = T_DOUBLE;
845    _value.d = value;
846  }
847 
848 jfloat get_jfloat() const { return _value.f; }
849 jdouble get_jdouble() const { return _value.d; }
850 jint get_jint() const { return _value.i; }
851 jlong get_jlong() const { return _value.l; }
852 jobject get_jobject() const { return _value.h; }
853 oopDesc* get_oop() const { return _value.o; }
854 JavaCallValue* get_value_addr() { return &_value; }
855 BasicType get_type() const { return _type; }
856 
857 void set_jfloat(jfloat f) { _value.f = f;}
858 void set_jdouble(jdouble d) { _value.d = d;}
859 void set_jint(jint i) { _value.i = i;}
860 void set_jlong(jlong l) { _value.l = l;}
861 void set_jobject(jobject h) { _value.h = h;}
862 void set_oop(oopDesc* o) { _value.o = o;}
863 void set_type(BasicType t) { _type = t; }
864 
865 jboolean get_jboolean() const { return (jboolean) (_value.i);}
866 jbyte get_jbyte() const { return (jbyte) (_value.i);}
867 jchar get_jchar() const { return (jchar) (_value.i);}
868 jshort get_jshort() const { return (jshort) (_value.i);}
869 
870};
871 
872 
873// TosState describes the top-of-stack state before and after the execution of
874// a bytecode or method. The top-of-stack value may be cached in one or more CPU
875// registers. The TosState corresponds to the 'machine representation' of this cached
876// value. There's 4 states corresponding to the JAVA types int, long, float & double
877// as well as a 5th state in case the top-of-stack value is actually on the top
878// of stack (in memory) and thus not cached. The atos state corresponds to the itos
879// state when it comes to machine representation but is used separately for (oop)
880// type specific operations (e.g. verification code).
881 
882enum TosState {         // describes the tos cache contents
883  btos = 0,             // byte, bool tos cached
884  ztos = 1,             // byte, bool tos cached
885  ctos = 2,             // char tos cached
886  stos = 3,             // short tos cached
887  itos = 4,             // int tos cached
888  ltos = 5,             // long tos cached
889  ftos = 6,             // float tos cached
890  dtos = 7,             // double tos cached
891  atos = 8,             // object cached
892  vtos = 9,             // tos not cached
893  number_of_states,
894  ilgl                  // illegal state: should not occur
895};
896 
897 
898inline TosState as_TosState(BasicType type) {
899  switch (type) {
900    case T_BYTE   : return btos;
901    case T_BOOLEAN: return ztos;
902    case T_CHAR   : return ctos;
903    case T_SHORT  : return stos;
904    case T_INT    : return itos;
905    case T_LONG   : return ltos;
906    case T_FLOAT  : return ftos;
907    case T_DOUBLE : return dtos;
908    case T_VOID   : return vtos;
909    case T_ARRAY  : // fall through
910    case T_OBJECT : return atos;
911    default       : return ilgl;
912  }
913}
914 
915inline BasicType as_BasicType(TosState state) {
916  switch (state) {
917    case btos : return T_BYTE;
918    case ztos : return T_BOOLEAN;
919    case ctos : return T_CHAR;
920    case stos : return T_SHORT;
921    case itos : return T_INT;
922    case ltos : return T_LONG;
923    case ftos : return T_FLOAT;
924    case dtos : return T_DOUBLE;
925    case atos : return T_OBJECT;
926    case vtos : return T_VOID;
927    default   : return T_ILLEGAL;
928  }
929}
930 
931 
932// Helper function to convert BasicType info into TosState
933// Note: Cannot define here as it uses global constant at the time being.
934TosState as_TosState(BasicType type);
935 
936 
937// JavaThreadState keeps track of which part of the code a thread is executing in. This
938// information is needed by the safepoint code.
939//
940// There are 4 essential states:
941//
942//  _thread_new         : Just started, but not executed init. code yet (most likely still in OS init code)
943//  _thread_in_native   : In native code. This is a safepoint region, since all oops will be in jobject handles
944//  _thread_in_vm       : Executing in the vm
945//  _thread_in_Java     : Executing either interpreted or compiled Java code (or could be in a stub)
946//
947// Each state has an associated xxxx_trans state, which is an intermediate state used when a thread is in
948// a transition from one state to another. These extra states makes it possible for the safepoint code to
949// handle certain thread_states without having to suspend the thread - making the safepoint code faster.
950//
951// Given a state, the xxxx_trans state can always be found by adding 1.
952//
953enum JavaThreadState {
954  _thread_uninitialized     =  0, // should never happen (missing initialization)
955  _thread_new               =  2, // just starting up, i.e., in process of being initialized
956  _thread_new_trans         =  3, // corresponding transition state (not used, included for completness)
957  _thread_in_native         =  4, // running in native code
958  _thread_in_native_trans   =  5, // corresponding transition state
959  _thread_in_vm             =  6, // running in VM
960  _thread_in_vm_trans       =  7, // corresponding transition state
961  _thread_in_Java           =  8, // running in Java or in stub code
962  _thread_in_Java_trans     =  9, // corresponding transition state (not used, included for completness)
963  _thread_blocked           = 10, // blocked in vm
964  _thread_blocked_trans     = 11, // corresponding transition state
965  _thread_max_state         = 12  // maximum thread state+1 - used for statistics allocation
966};
967 
968//----------------------------------------------------------------------------------------------------
969// Special constants for debugging
970 
971const jint     badInt           = -3;                       // generic "bad int" value
972const intptr_t badAddressVal    = -2;                       // generic "bad address" value
973const intptr_t badOopVal        = -1;                       // generic "bad oop" value
974const intptr_t badHeapOopVal    = (intptr_t) CONST64(0x2BAD4B0BBAADBABE)(0x2BAD4B0BBAADBABELL); // value used to zap heap after GC
975const int      badStackSegVal   = 0xCA;                     // value used to zap stack segments
976const int      badHandleValue   = 0xBC;                     // value used to zap vm handle area
977const int      badResourceValue = 0xAB;                     // value used to zap resource area
978const int      freeBlockPad     = 0xBA;                     // value used to pad freed blocks.
979const int      uninitBlockPad   = 0xF1;                     // value used to zap newly malloc'd blocks.
980const juint    uninitMetaWordVal= 0xf7f7f7f7;               // value used to zap newly allocated metachunk
981const juint    badHeapWordVal   = 0xBAADBABE;               // value used to zap heap after GC
982const juint    badMetaWordVal   = 0xBAADFADE;               // value used to zap metadata heap after GC
983const int      badCodeHeapNewVal= 0xCC;                     // value used to zap Code heap at allocation
984const int      badCodeHeapFreeVal = 0xDD;                   // value used to zap Code heap at deallocation
985 
986 
987// (These must be implemented as #defines because C++ compilers are
988// not obligated to inline non-integral constants!)
989#define       badAddress((address)::badAddressVal)        ((address)::badAddressVal)
990#define       badOop(cast_to_oop(::badOopVal))            (cast_to_oop(::badOopVal))
991#define       badHeapWord(::badHeapWordVal)       (::badHeapWordVal)
992 
993// Default TaskQueue size is 16K (32-bit) or 128K (64-bit)
994#define TASKQUEUE_SIZE( 1<<17) (NOT_LP64(1<<14) LP64_ONLY(1<<17)1<<17)
995 
996//----------------------------------------------------------------------------------------------------
997// Utility functions for bitfield manipulations
998 
999const intptr_t AllBits    = ~0; // all bits set in a word
1000const intptr_t NoBits     =  0; // no bits set in a word
1001const jlong    NoLongBits =  0; // no bits set in a long
1002const intptr_t OneBit     =  1; // only right_most bit set in a word
1003 
1004// get a word with the n.th or the right-most or left-most n bits set
1005// (note: #define used only so that they can be used in enum constant definitions)
1006#define nth_bit(n)(((n) >= BitsPerWord) ? 0 : (OneBit << (n)))        (((n) >= BitsPerWord) ? 0 : (OneBit << (n)))
1007#define right_n_bits(n)((((n) >= BitsPerWord) ? 0 : (OneBit << (n))) - 1)   (nth_bit(n)(((n) >= BitsPerWord) ? 0 : (OneBit << (n))) - 1)
1008 
1009// bit-operations using a mask m
1010inline void   set_bits    (intptr_t& x, intptr_t m) { x |= m; }
1011inline void clear_bits    (intptr_t& x, intptr_t m) { x &= ~m; }
1012inline intptr_t mask_bits      (intptr_t  x, intptr_t m) { return x & m; }
1013inline jlong    mask_long_bits (jlong     x, jlong    m) { return x & m; }
1014inline bool mask_bits_are_true (intptr_t flags, intptr_t mask) { return (flags & mask) == mask; }
1015 
1016// bit-operations using the n.th bit
1017inline void    set_nth_bit(intptr_t& x, int n) { set_bits  (x, nth_bit(n)(((n) >= BitsPerWord) ? 0 : (OneBit << (n)))); }
1018inline void  clear_nth_bit(intptr_t& x, int n) { clear_bits(x, nth_bit(n)(((n) >= BitsPerWord) ? 0 : (OneBit << (n)))); }
1019inline bool is_set_nth_bit(intptr_t  x, int n) { return mask_bits (x, nth_bit(n)(((n) >= BitsPerWord) ? 0 : (OneBit << (n)))) != NoBits; }
1020 
1021// returns the bitfield of x starting at start_bit_no with length field_length (no sign-extension!)
1022inline intptr_t bitfield(intptr_t x, int start_bit_no, int field_length) {
1023  return mask_bits(x >> start_bit_no, right_n_bits(field_length)((((field_length) >= BitsPerWord) ? 0 : (OneBit << (
field_length))) - 1));
1024}
1025 
1026 
1027//----------------------------------------------------------------------------------------------------
1028// Utility functions for integers
1029 
1030// Avoid use of global min/max macros which may cause unwanted double
1031// evaluation of arguments.
1032#ifdef max
1033#undef max
1034#endif
1035 
1036#ifdef min
1037#undef min
1038#endif
1039 
1040// It is necessary to use templates here. Having normal overloaded
1041// functions does not work because it is necessary to provide both 32-
1042// and 64-bit overloaded functions, which does not work, and having
1043// explicitly-typed versions of these routines (i.e., MAX2I, MAX2L)
1044// will be even more error-prone than macros.
1045template<class T> constexpr T MAX2(T a, T b)           { return (a > b) ? a : b; }
1046template<class T> constexpr T MIN2(T a, T b)           { return (a < b) ? a : b; }
1047template<class T> constexpr T MAX3(T a, T b, T c)      { return MAX2(MAX2(a, b), c); }
1048template<class T> constexpr T MIN3(T a, T b, T c)      { return MIN2(MIN2(a, b), c); }
1049template<class T> constexpr T MAX4(T a, T b, T c, T d) { return MAX2(MAX3(a, b, c), d); }
1050template<class T> constexpr T MIN4(T a, T b, T c, T d) { return MIN2(MIN3(a, b, c), d); }
1051 
1052template<class T> inline T ABS(T x)                 { return (x > 0) ? x : -x; }
1053 
1054// Return the given value clamped to the range [min ... max]
1055template<typename T>
1056inline T clamp(T value, T min, T max) {
1057  assert(min <= max, "must be")do { if (!(min <= max)) { (*g_assert_poison) = 'X';; report_vm_error
("/home/daniel/Projects/java/jdk/src/hotspot/share/utilities/globalDefinitions.hpp"
, 1057, "assert(" "min <= max" ") failed", "must be"); ::breakpoint
(); } } while (0);
1058  return MIN2(MAX2(value, min), max);
1059}
1060 
1061inline bool is_odd (intx x) { return x & 1;      }
1062inline bool is_even(intx x) { return !is_odd(x); }
1063 
1064// abs methods which cannot overflow and so are well-defined across
1065// the entire domain of integer types.
1066static inline unsigned int uabs(unsigned int n) {
1067  union {
1068    unsigned int result;
1069    int value;
1070  };
1071  result = n;
1072  if (value < 0) result = 0-result;
1073  return result;
1074}
1075static inline julong uabs(julong n) {
1076  union {
1077    julong result;
1078    jlong value;
1079  };
1080  result = n;
1081  if (value < 0) result = 0-result;
1082  return result;
1083}
1084static inline julong uabs(jlong n) { return uabs((julong)n); }
1085static inline unsigned int uabs(int n) { return uabs((unsigned int)n); }
1086 
1087// "to" should be greater than "from."
1088inline intx byte_size(void* from, void* to) {
1089  return (address)to - (address)from;
1090}
1091 
1092 
1093// Pack and extract shorts to/from ints:
1094 
1095inline int extract_low_short_from_int(jint x) {
1096  return x & 0xffff;
1097}
1098 
1099inline int extract_high_short_from_int(jint x) {
1100  return (x >> 16) & 0xffff;
1101}
1102 
1103inline int build_int_from_shorts( jushort low, jushort high ) {
1104  return ((int)((unsigned int)high << 16) | (unsigned int)low);
1105}
1106 
1107// swap a & b
1108template<class T> static void swap(T& a, T& b) {
1109  T tmp = a;
1110  a = b;
1111  b = tmp;
1112}
1113 
1114// array_size_impl is a function that takes a reference to T[N] and
1115// returns a reference to char[N].  It is not ODR-used, so not defined.
1116template<typename T, size_t N> char (&array_size_impl(T (&)[N]))[N];
1117 
1118#define ARRAY_SIZE(array)sizeof(array_size_impl(array)) sizeof(array_size_impl(array))
1119 
1120//----------------------------------------------------------------------------------------------------
1121// Sum and product which can never overflow: they wrap, just like the
1122// Java operations.  Note that we don't intend these to be used for
1123// general-purpose arithmetic: their purpose is to emulate Java
1124// operations.
1125 
1126// The goal of this code to avoid undefined or implementation-defined
1127// behavior.  The use of an lvalue to reference cast is explicitly
1128// permitted by Lvalues and rvalues [basic.lval].  [Section 3.10 Para
1129// 15 in C++03]
1130#define JAVA_INTEGER_OP(OP, NAME, TYPE, UNSIGNED_TYPE)  \
1131inline TYPE NAME (TYPE in1, TYPE in2) {                 \
1132  UNSIGNED_TYPE ures = static_cast<UNSIGNED_TYPE>(in1); \
1133  ures OP ## = static_cast<UNSIGNED_TYPE>(in2);         \
1134  return reinterpret_cast<TYPE&>(ures);                 \
1135}
1136 
1137JAVA_INTEGER_OP(+, java_add, jint, juint)
1138JAVA_INTEGER_OP(-, java_subtract, jint, juint)
1139JAVA_INTEGER_OP(*, java_multiply, jint, juint)
1140JAVA_INTEGER_OP(+, java_add, jlong, julong)
1141JAVA_INTEGER_OP(-, java_subtract, jlong, julong)
1142JAVA_INTEGER_OP(*, java_multiply, jlong, julong)
1143 
1144#undef JAVA_INTEGER_OP
1145 
1146// Provide integer shift operations with Java semantics.  No overflow
1147// issues - left shifts simply discard shifted out bits.  No undefined
1148// behavior for large or negative shift quantities; instead the actual
1149// shift distance is the argument modulo the lhs value's size in bits.
1150// No undefined or implementation defined behavior for shifting negative
1151// values; left shift discards bits, right shift sign extends.  We use
1152// the same safe conversion technique as above for java_add and friends.
1153#define JAVA_INTEGER_SHIFT_OP(OP, NAME, TYPE, XTYPE)    \
1154inline TYPE NAME (TYPE lhs, jint rhs) {                 \
1155  const uint rhs_mask = (sizeof(TYPE) * 8) - 1;         \
1156  STATIC_ASSERT(rhs_mask == 31 || rhs_mask == 63)static_assert((rhs_mask == 31 || rhs_mask == 63), "rhs_mask == 31 || rhs_mask == 63"
);      \
1157  XTYPE xres = static_cast<XTYPE>(lhs);                 \
1158  xres OP ## = (rhs & rhs_mask);                        \
1159  return reinterpret_cast<TYPE&>(xres);                 \
1160}
1161 
1162JAVA_INTEGER_SHIFT_OP(<<, java_shift_left, jint, juint)
1163JAVA_INTEGER_SHIFT_OP(<<, java_shift_left, jlong, julong)
1164// For signed shift right, assume C++ implementation >> sign extends.
1165JAVA_INTEGER_SHIFT_OP(>>, java_shift_right, jint, jint)
1166JAVA_INTEGER_SHIFT_OP(>>, java_shift_right, jlong, jlong)
1167// For >>> use C++ unsigned >>.
1168JAVA_INTEGER_SHIFT_OP(>>, java_shift_right_unsigned, jint, juint)
1169JAVA_INTEGER_SHIFT_OP(>>, java_shift_right_unsigned, jlong, julong)
1170 
1171#undef JAVA_INTEGER_SHIFT_OP
1172 
1173//----------------------------------------------------------------------------------------------------
1174// The goal of this code is to provide saturating operations for int/uint.
1175// Checks overflow conditions and saturates the result to min_jint/max_jint.
1176#define SATURATED_INTEGER_OP(OP, NAME, TYPE1, TYPE2) \
1177inline int NAME (TYPE1 in1, TYPE2 in2) {             \
1178  jlong res = static_cast<jlong>(in1);               \
1179  res OP ## = static_cast<jlong>(in2);               \
1180  if (res > max_jint) {                              \
1181    res = max_jint;                                  \
1182  } else if (res < min_jint) {                       \
1183    res = min_jint;                                  \
1184  }                                                  \
1185  return static_cast<int>(res);                      \
1186}
1187 
1188SATURATED_INTEGER_OP(+, saturated_add, int, int)
1189SATURATED_INTEGER_OP(+, saturated_add, int, uint)
1190SATURATED_INTEGER_OP(+, saturated_add, uint, int)
1191SATURATED_INTEGER_OP(+, saturated_add, uint, uint)
1192 
1193#undef SATURATED_INTEGER_OP
1194 
1195// Dereference vptr
1196// All C++ compilers that we know of have the vtbl pointer in the first
1197// word.  If there are exceptions, this function needs to be made compiler
1198// specific.
1199static inline void* dereference_vptr(const void* addr) {
1200  return *(void**)addr;
11
←
Undefined or garbage value returned to caller
1201}
1202 
1203//----------------------------------------------------------------------------------------------------
1204// String type aliases used by command line flag declarations and
1205// processing utilities.
1206 
1207typedef const char* ccstr;
1208typedef const char* ccstrlist;   // represents string arguments which accumulate
1209 
1210//----------------------------------------------------------------------------------------------------
1211// Default hash/equals functions used by ResourceHashtable
1212 
1213template<typename K> unsigned primitive_hash(const K& k) {
1214  unsigned hash = (unsigned)((uintptr_t)k);
1215  return hash ^ (hash >> 3); // just in case we're dealing with aligned ptrs
1216}
1217 
1218template<typename K> bool primitive_equals(const K& k0, const K& k1) {
1219  return k0 == k1;
1220}
1221 
1222 
1223#endif // SHARE_UTILITIES_GLOBALDEFINITIONS_HPP