src/hotspot/share/prims/jni.cpp
author rprotacio
Mon, 12 Jun 2017 13:58:09 -0400
changeset 48558 b2b67c8fc91a
parent 48105 8d15b1369c7a
child 48819 ee513596f3ee
permissions -rw-r--r--
8181664: Improve JVM UTF String handling Reviewed-by: mschoene, coleenp, rhalade, acorn, gtriantafill Contributed-by: rachel.protacio@oracle.com
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
     2
 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
13958
f5598a86c223 7170638: Use DTRACE_PROBE[N] in JNI Set and SetStatic Field.
coleenp
parents: 13952
diff changeset
     3
 * Copyright (c) 2012 Red Hat, Inc.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    20
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    21
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5403
diff changeset
    22
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    26
#include "precompiled.hpp"
47659
a8e9aff89f7b 8189608: Remove duplicated jni.h
ihse
parents: 47634
diff changeset
    27
#include "jni.h"
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
    28
#include "jvm.h"
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
    29
#include "ci/ciReplay.hpp"
13087
673ea6efaf18 7158800: Improve storage of symbol tables
coleenp
parents: 12939
diff changeset
    30
#include "classfile/altHashing.hpp"
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
    31
#include "classfile/classFileStream.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    32
#include "classfile/classLoader.hpp"
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
    33
#include "classfile/javaClasses.hpp"
35498
392b50de06c6 8146401: Clean up oop.hpp: add inline directives and fix header files
goetz
parents: 35219
diff changeset
    34
#include "classfile/javaClasses.inline.hpp"
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
    35
#include "classfile/modules.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    36
#include "classfile/symbolTable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    37
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    38
#include "classfile/vmSymbols.hpp"
30764
fec48bf5a827 8079792: GC directory structure cleanup
pliden
parents: 30143
diff changeset
    39
#include "gc/shared/gcLocker.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    40
#include "interpreter/linkResolver.hpp"
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 13087
diff changeset
    41
#include "memory/allocation.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    42
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    43
#include "memory/oopFactory.hpp"
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 37179
diff changeset
    44
#include "memory/resourceArea.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    45
#include "memory/universe.inline.hpp"
47998
fb0275c320a0 8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents: 47796
diff changeset
    46
#include "oops/access.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    47
#include "oops/instanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    48
#include "oops/instanceOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    49
#include "oops/markOop.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
    50
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    51
#include "oops/objArrayKlass.hpp"
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 27685
diff changeset
    52
#include "oops/objArrayOop.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    53
#include "oops/oop.inline.hpp"
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
    54
#include "oops/symbol.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    55
#include "oops/typeArrayKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    56
#include "oops/typeArrayOop.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    57
#include "prims/jniCheck.hpp"
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
    58
#include "prims/jniExport.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    59
#include "prims/jniFastGetField.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    60
#include "prims/jvm_misc.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    61
#include "prims/jvmtiExport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    62
#include "prims/jvmtiThreadState.hpp"
40655
9f644073d3a0 8157907: Incorrect inclusion of atomic.hpp instead of atomic.inline.hpp
dholmes
parents: 38704
diff changeset
    63
#include "runtime/atomic.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    64
#include "runtime/compilationPolicy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    65
#include "runtime/fieldDescriptor.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    66
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    67
#include "runtime/interfaceSupport.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    68
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    69
#include "runtime/javaCalls.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    70
#include "runtime/jfieldIDWorkaround.hpp"
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 24237
diff changeset
    71
#include "runtime/orderAccess.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    72
#include "runtime/reflection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    73
#include "runtime/sharedRuntime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    74
#include "runtime/signature.hpp"
14583
d70ee55535f4 8003935: Simplify the needed includes for using Thread::current()
stefank
parents: 14490
diff changeset
    75
#include "runtime/thread.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    76
#include "runtime/vm_operations.hpp"
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25633
diff changeset
    77
#include "services/memTracker.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    78
#include "services/runtimeService.hpp"
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 36183
diff changeset
    79
#include "trace/traceMacros.hpp"
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
    80
#include "trace/tracing.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    81
#include "utilities/defaultStream.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    82
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    83
#include "utilities/events.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6176
diff changeset
    84
#include "utilities/histogram.hpp"
35519
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
    85
#include "utilities/internalVMTests.hpp"
27684
e0391b2bf625 8064581: Move INCLUDE_ALL_GCS include section to the end of the include list
stefank
parents: 27679
diff changeset
    86
#include "utilities/macros.hpp"
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46431
diff changeset
    87
#include "utilities/vmError.hpp"
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    88
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    89
#include "jvmci/jvmciCompiler.hpp"
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    90
#include "jvmci/jvmciRuntime.hpp"
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
    91
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
47613
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
    93
static jint CurrentVersion = JNI_VERSION_10;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
    95
#ifdef _WIN32
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
    96
extern LONG WINAPI topLevelExceptionFilter(_EXCEPTION_POINTERS* );
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
    97
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
// The DT_RETURN_MARK macros create a scoped object to fire the dtrace
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
// '-return' probe regardless of the return path is taken out of the function.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
// Methods that have multiple return paths use this to avoid having to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
// instrument each return path.  Methods that use CHECK or THROW must use this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
// since those macros can cause an immedate uninstrumented return.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
// In order to get the return value, a reference to the variable containing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
// the return value must be passed to the contructor of the object, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
// the return value must be set before return (since the mark object has
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
// a reference to it).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
// Example:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// DT_RETURN_MARK_DECL(SomeFunc, int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
// JNI_ENTRY(int, SomeFunc, ...)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
//   int return_value = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
//   DT_RETURN_MARK(SomeFunc, int, (const int&)return_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
//   foo(CHECK_0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
//   return_value = 5;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
//   return return_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
// JNI_END
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   119
#define DT_RETURN_MARK_DECL(name, type, probe)                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   120
  DTRACE_ONLY(                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   121
    class DTraceReturnProbeMark_##name {                                   \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   122
     public:                                                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   123
      const type& _ret_ref;                                                \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   124
      DTraceReturnProbeMark_##name(const type& v) : _ret_ref(v) {}         \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   125
      ~DTraceReturnProbeMark_##name() {                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   126
        probe;                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   127
      }                                                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   128
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   129
  )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   130
// Void functions are simpler since there's no return value
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   131
#define DT_VOID_RETURN_MARK_DECL(name, probe)                              \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   132
  DTRACE_ONLY(                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   133
    class DTraceReturnProbeMark_##name {                                   \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   134
     public:                                                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   135
      ~DTraceReturnProbeMark_##name() {                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   136
        probe;                                                             \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   137
      }                                                                    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   138
    }                                                                      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   139
  )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
// Place these macros in the function to mark the return.  Non-void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
// functions need the type and address of the return value.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
#define DT_RETURN_MARK(name, type, ref) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark(ref) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
#define DT_VOID_RETURN_MARK(name) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  DTRACE_ONLY( DTraceReturnProbeMark_##name dtrace_return_mark )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
// Use these to select distinct code for floating-point vs. non-floating point
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
// situations.  Used from within common macros where we need slightly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
// different behavior for Float/Double
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
#define FP_SELECT_Boolean(intcode, fpcode) intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
#define FP_SELECT_Byte(intcode, fpcode)    intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
#define FP_SELECT_Char(intcode, fpcode)    intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
#define FP_SELECT_Short(intcode, fpcode)   intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
#define FP_SELECT_Object(intcode, fpcode)  intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
#define FP_SELECT_Int(intcode, fpcode)     intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
#define FP_SELECT_Long(intcode, fpcode)    intcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
#define FP_SELECT_Float(intcode, fpcode)   fpcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
#define FP_SELECT_Double(intcode, fpcode)  fpcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
#define FP_SELECT(TypeName, intcode, fpcode) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  FP_SELECT_##TypeName(intcode, fpcode)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
// Choose DT_RETURN_MARK macros  based on the type: float/double -> void
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
// (dtrace doesn't do FP yet)
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   166
#define DT_RETURN_MARK_DECL_FOR(TypeName, name, type, probe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   167
  FP_SELECT(TypeName, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   168
    DT_RETURN_MARK_DECL(name, type, probe), DT_VOID_RETURN_MARK_DECL(name, probe) )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
#define DT_RETURN_MARK_FOR(TypeName, name, type, ref) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  FP_SELECT(TypeName, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
    DT_RETURN_MARK(name, type, ref), DT_VOID_RETURN_MARK(name) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
// out-of-line helpers for class jfieldIDWorkaround:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   176
bool jfieldIDWorkaround::is_valid_jfieldID(Klass* k, jfieldID id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  if (jfieldIDWorkaround::is_instance_jfieldID(k, id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
    uintptr_t as_uint = (uintptr_t) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    intptr_t offset = raw_instance_offset(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    if (is_checked_jfieldID(id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      if (!klass_hash_ok(k, id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
        return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   185
    return InstanceKlass::cast(k)->contains_field_offset(offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    JNIid* result = (JNIid*) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    return result != NULL && result->is_static_field_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    return result != NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   197
intptr_t jfieldIDWorkaround::encode_klass_hash(Klass* k, intptr_t offset) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  if (offset <= small_offset_mask) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   199
    Klass* field_klass = k;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   200
    Klass* super_klass = field_klass->super();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   201
    // With compressed oops the most super class with nonstatic fields would
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   202
    // be the owner of fields embedded in the header.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   203
    while (InstanceKlass::cast(super_klass)->has_nonstatic_fields() &&
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   204
           InstanceKlass::cast(super_klass)->contains_field_offset(offset)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
      field_klass = super_klass;   // super contains the field also
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   206
      super_klass = field_klass->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
    }
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
   208
    debug_only(NoSafepointVerifier nosafepoint;)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    uintptr_t klass_hash = field_klass->identity_hash();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
#if 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
      ResourceMark rm;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   216
      warning("VerifyJNIFields: long offset %d in %s", offset, k->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   224
bool jfieldIDWorkaround::klass_hash_ok(Klass* k, jfieldID id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  uintptr_t as_uint = (uintptr_t) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  do {
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
   228
    debug_only(NoSafepointVerifier nosafepoint;)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
    // Could use a non-blocking query for identity_hash here...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    if ((k->identity_hash() & klass_mask) == klass_hash)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
      return true;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   232
    k = k->super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  } while (k != NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   237
void jfieldIDWorkaround::verify_instance_jfieldID(Klass* k, jfieldID id) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  guarantee(jfieldIDWorkaround::is_instance_jfieldID(k, id), "must be an instance field" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  uintptr_t as_uint = (uintptr_t) id;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  intptr_t offset = raw_instance_offset(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  if (VerifyJNIFields) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    if (is_checked_jfieldID(id)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
      guarantee(klass_hash_ok(k, id),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    "Bug in native code: jfieldID class must match object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
#if 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
      #ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
      if (Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  ResourceMark rm;
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   250
  warning("VerifyJNIFields: unverified offset %d for %s", offset, k->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
      #endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   256
  guarantee(InstanceKlass::cast(k)->contains_field_offset(offset),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
      "Bug in native code: jfieldID offset must address interior of object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
// Wrapper to trace JNI functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  Histogram* JNIHistogram;
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
   264
  static volatile int JNIHistogram_lock = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  class JNIHistogramElement : public HistogramElement {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
     JNIHistogramElement(const char* name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  };
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
  JNIHistogramElement::JNIHistogramElement(const char* elementName) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
    _name = elementName;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    uintx count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    while (Atomic::cmpxchg(1, &JNIHistogram_lock, 0) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
      while (OrderAccess::load_acquire(&JNIHistogram_lock) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
        count +=1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
        if ( (WarnOnStalledSpinLock > 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
          && (count % WarnOnStalledSpinLock == 0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
          warning("JNIHistogram_lock seems to be stalled");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    if(JNIHistogram == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
      JNIHistogram = new Histogram("JNI Call Counts",100);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
    JNIHistogram->add_element(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    Atomic::dec(&JNIHistogram_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  #define JNICountWrapper(arg)                                     \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
     static JNIHistogramElement* e = new JNIHistogramElement(arg); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
      /* There is a MT-race condition in VC++. So we need to make sure that that e has been initialized */ \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
     if (e != NULL) e->increment_count()
34285
0b07014c15e9 8143155: Remove TraceRuntimeCalls, TraceJNICalls, and TraceJVMCalls rather than convert to UL
rprotacio
parents: 33813
diff changeset
   297
  #define JNIWrapper(arg) JNICountWrapper(arg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  #define JNIWrapper(arg)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
// Implementation of JNI entries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   305
DT_RETURN_MARK_DECL(DefineClass, jclass
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   306
                    , HOTSPOT_JNI_DEFINECLASS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
JNI_ENTRY(jclass, jni_DefineClass(JNIEnv *env, const char *name, jobject loaderRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
                                  const jbyte *buf, jsize bufLen))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  JNIWrapper("DefineClass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   312
  HOTSPOT_JNI_DEFINECLASS_ENTRY(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   313
    env, (char*) name, loaderRef, (char*) buf, bufLen);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   314
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  jclass cls = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  DT_RETURN_MARK(DefineClass, jclass, (const jclass&)cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
12939
c0a910665895 7171703: JNI DefineClass crashes client VM when first parameter is NULL
fparain
parents: 11480
diff changeset
   318
  TempNewSymbol class_name = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  // Since exceptions can be thrown, class initialization can take place
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  // if name is NULL no check for class name in .class stream has to be made.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  if (name != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    const int str_len = (int)strlen(name);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   323
    if (str_len > Symbol::max_length()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
      // It's impossible to create this class;  the name cannot fit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
      // into the constant pool.
46431
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   326
      Exceptions::fthrow(THREAD_AND_LOCATION,
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   327
                         vmSymbols::java_lang_NoClassDefFoundError(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   328
                         "Class name exceeds maximum length of %d: %s",
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   329
                         Symbol::max_length(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   330
                         name);
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   331
      return 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
    }
12939
c0a910665895 7171703: JNI DefineClass crashes client VM when first parameter is NULL
fparain
parents: 11480
diff changeset
   333
    class_name = SymbolTable::new_symbol(name, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
  ResourceMark rm(THREAD);
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   336
  ClassFileStream st((u1*)buf, bufLen, NULL, ClassFileStream::verify);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  Handle class_loader (THREAD, JNIHandles::resolve(loaderRef));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  if (UsePerfData && !class_loader.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
    // check whether the current caller thread holds the lock or not.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    // If not, increment the corresponding counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    if (ObjectSynchronizer::
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
        query_lock_ownership((JavaThread*)THREAD, class_loader) !=
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
        ObjectSynchronizer::owner_self) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
      ClassLoader::sync_JNIDefineClassLockFreeCounter()->inc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  }
34666
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   348
  Klass* k = SystemDictionary::resolve_from_stream(class_name,
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   349
                                                   class_loader,
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   350
                                                   Handle(),
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   351
                                                   &st,
1c7168ea0034 8140485: Class load and creation cleanup
mgronlun
parents: 34649
diff changeset
   352
                                                   CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 37483
diff changeset
   354
  if (log_is_enabled(Debug, class, resolve) && k != NULL) {
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   355
    trace_class_resolution(k);
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   356
  }
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   357
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
  cls = (jclass)JNIHandles::make_local(
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   359
    env, k->java_mirror());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  return cls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
static bool first_time_FindClass = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   367
DT_RETURN_MARK_DECL(FindClass, jclass
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   368
                    , HOTSPOT_JNI_FINDCLASS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
JNI_ENTRY(jclass, jni_FindClass(JNIEnv *env, const char *name))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  JNIWrapper("FindClass");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   372
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   373
  HOTSPOT_JNI_FINDCLASS_ENTRY(env, (char *)name);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  jclass result = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  DT_RETURN_MARK(FindClass, jclass, (const jclass&)result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  // Remember if we are the first invocation of jni_FindClass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  bool first_time = first_time_FindClass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  first_time_FindClass = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  // Sanity check the name:  it cannot be null or larger than the maximum size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  // name we can fit in the constant pool.
46431
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   384
  if (name == NULL) {
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   385
    THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), "No class name given");
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   386
  }
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   387
  if ((int)strlen(name) > Symbol::max_length()) {
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   388
    Exceptions::fthrow(THREAD_AND_LOCATION,
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   389
                       vmSymbols::java_lang_NoClassDefFoundError(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   390
                       "Class name exceeds maximum length of %d: %s",
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   391
                       Symbol::max_length(),
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   392
                       name);
87b0d1afe03e 8056900: Enhance NoClassDefFound exception messaging
hseigel
parents: 46369
diff changeset
   393
    return 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  //%note jni_3
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  Handle protection_domain;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  // Find calling class
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   399
  Klass* k = thread->security_get_caller_class(0);
47662
2493edd8b479 8189193: FindClass should only see classes from the boot loader called from its associated native library
mchung
parents: 47659
diff changeset
   400
  // default to the system loader when no context
2493edd8b479 8189193: FindClass should only see classes from the boot loader called from its associated native library
mchung
parents: 47659
diff changeset
   401
  Handle loader(THREAD, SystemDictionary::java_system_loader());
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   402
  if (k != NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
    // Special handling to make sure JNI_OnLoad and JNI_OnUnload are executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
    // in the correct class context.
47613
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   405
    if (k->class_loader() == NULL &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
        k->name() == vmSymbols::java_lang_ClassLoader_NativeLibrary()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
      JavaValue result(T_OBJECT);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
      JavaCalls::call_static(&result, k,
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   409
                             vmSymbols::getFromClass_name(),
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   410
                             vmSymbols::void_class_signature(),
47613
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   411
                             CHECK_NULL);
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   412
      // When invoked from JNI_OnLoad, NativeLibrary::getFromClass returns
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   413
      // a non-NULL Class object.  When invoked from JNI_OnUnload,
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   414
      // it will return NULL to indicate no context.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
      oop mirror = (oop) result.get_jobject();
47613
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   416
      if (mirror != NULL) {
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   417
        Klass* fromClass = java_lang_Class::as_Klass(mirror);
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   418
        loader = Handle(THREAD, fromClass->class_loader());
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   419
        protection_domain = Handle(THREAD, fromClass->protection_domain());
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   420
      }
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   421
    } else {
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   422
      loader = Handle(THREAD, k->class_loader());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
    }
47613
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   424
  }
af241e3e5a13 8188052: JNI FindClass needs to specify the class loading context used for library lifecycle hooks
mchung
parents: 47216
diff changeset
   425
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   426
  TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  result = find_class_from_class_loader(env, sym, true, loader,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
                                        protection_domain, true, thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 37483
diff changeset
   430
  if (log_is_enabled(Debug, class, resolve) && result != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   431
    trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   432
  }
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
   433
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  // If we were the first invocation of jni_FindClass, we enable compilation again
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  // rather than just allowing invocation counter to overflow and decay.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  // Controlled by flag DelayCompilationDuringStartup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  if (first_time && !CompileTheWorld)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
    CompilationPolicy::completed_vm_startup();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   443
DT_RETURN_MARK_DECL(FromReflectedMethod, jmethodID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   444
                    , HOTSPOT_JNI_FROMREFLECTEDMETHOD_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
JNI_ENTRY(jmethodID, jni_FromReflectedMethod(JNIEnv *env, jobject method))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  JNIWrapper("FromReflectedMethod");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   448
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   449
  HOTSPOT_JNI_FROMREFLECTEDMETHOD_ENTRY(env, method);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   450
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  jmethodID ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  DT_RETURN_MARK(FromReflectedMethod, jmethodID, (const jmethodID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  // method is a handle to a java.lang.reflect.Method object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  oop reflected  = JNIHandles::resolve_non_null(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  oop mirror     = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  int slot       = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   459
  if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
    mirror = java_lang_reflect_Constructor::clazz(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
    slot   = java_lang_reflect_Constructor::slot(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  } else {
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   463
    assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
    mirror = java_lang_reflect_Method::clazz(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
    slot   = java_lang_reflect_Method::slot(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   467
  Klass* k1 = java_lang_Class::as_Klass(mirror);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   468
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  // Make sure class is initialized before handing id's out to methods
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   470
  k1->initialize(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   471
  Method* m = InstanceKlass::cast(k1)->method_with_idnum(slot);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  ret = m==NULL? NULL : m->jmethod_id();  // return NULL if reflected method deleted
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   476
DT_RETURN_MARK_DECL(FromReflectedField, jfieldID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   477
                    , HOTSPOT_JNI_FROMREFLECTEDFIELD_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
JNI_ENTRY(jfieldID, jni_FromReflectedField(JNIEnv *env, jobject field))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  JNIWrapper("FromReflectedField");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   481
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   482
  HOTSPOT_JNI_FROMREFLECTEDFIELD_ENTRY(env, field);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   483
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  jfieldID ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  DT_RETURN_MARK(FromReflectedField, jfieldID, (const jfieldID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  // field is a handle to a java.lang.reflect.Field object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  oop reflected   = JNIHandles::resolve_non_null(field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  oop mirror      = java_lang_reflect_Field::clazz(reflected);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   490
  Klass* k1       = java_lang_Class::as_Klass(mirror);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  int slot        = java_lang_reflect_Field::slot(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  int modifiers   = java_lang_reflect_Field::modifiers(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  // Make sure class is initialized before handing id's out to fields
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   495
  k1->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  // First check if this is a static field
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  if (modifiers & JVM_ACC_STATIC) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   499
    intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   500
    JNIid* id = InstanceKlass::cast(k1)->jni_id_for(offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
    assert(id != NULL, "corrupt Field object");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
    debug_only(id->set_is_static_field_id();)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   503
    // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    ret = jfieldIDWorkaround::to_static_jfieldID(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // The slot is the index of the field description in the field-array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  // The jfieldID is the offset of the field within the object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  // It may also have hash bits for k, if VerifyJNIFields is turned on.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   511
  intptr_t offset = InstanceKlass::cast(k1)->field_offset( slot );
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   512
  assert(InstanceKlass::cast(k1)->contains_field_offset(offset), "stay within object");
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   513
  ret = jfieldIDWorkaround::to_instance_jfieldID(k1, offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   517
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   518
DT_RETURN_MARK_DECL(ToReflectedMethod, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   519
                    , HOTSPOT_JNI_TOREFLECTEDMETHOD_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
JNI_ENTRY(jobject, jni_ToReflectedMethod(JNIEnv *env, jclass cls, jmethodID method_id, jboolean isStatic))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  JNIWrapper("ToReflectedMethod");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   523
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   524
  HOTSPOT_JNI_TOREFLECTEDMETHOD_ENTRY(env, cls, (uintptr_t) method_id, isStatic);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   525
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  DT_RETURN_MARK(ToReflectedMethod, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   529
  methodHandle m (THREAD, Method::resolve_jmethod_id(method_id));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  assert(m->is_static() == (isStatic != 0), "jni_ToReflectedMethod access flags doesn't match");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  oop reflection_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  if (m->is_initializer()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    reflection_method = Reflection::new_constructor(m, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  } else {
24456
8c7933fa5a1f 8025580: Temporary flags: UseNewReflection and ReflectionWrapResolutionErrors
coleenp
parents: 24424
diff changeset
   535
    reflection_method = Reflection::new_method(m, false, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  ret = JNIHandles::make_local(env, reflection_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   541
DT_RETURN_MARK_DECL(GetSuperclass, jclass
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   542
                    , HOTSPOT_JNI_GETSUPERCLASS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
JNI_ENTRY(jclass, jni_GetSuperclass(JNIEnv *env, jclass sub))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  JNIWrapper("GetSuperclass");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   546
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   547
  HOTSPOT_JNI_GETSUPERCLASS_ENTRY(env, sub);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   548
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  jclass obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  DT_RETURN_MARK(GetSuperclass, jclass, (const jclass&)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  oop mirror = JNIHandles::resolve_non_null(sub);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  // primitive classes return NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  if (java_lang_Class::is_primitive(mirror)) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  // Rules of Class.getSuperClass as implemented by KLass::java_super:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  // arrays return Object
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // interfaces return NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  // proper classes return Klass::super()
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   560
  Klass* k = java_lang_Class::as_Klass(mirror);
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   561
  if (k->is_interface()) return NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  // return mirror for superclass
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   564
  Klass* super = k->java_super();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  // super2 is the value computed by the compiler's getSuperClass intrinsic:
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
   566
  debug_only(Klass* super2 = ( k->is_array_klass()
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   567
                                 ? SystemDictionary::Object_klass()
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   568
                                 : k->super() ) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  assert(super == super2,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
         "java_super computation depends on interface, array, other super");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   571
  obj = (super == NULL) ? NULL : (jclass) JNIHandles::make_local(super->java_mirror());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
JNI_QUICK_ENTRY(jboolean, jni_IsAssignableFrom(JNIEnv *env, jclass sub, jclass super))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  JNIWrapper("IsSubclassOf");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   577
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   578
  HOTSPOT_JNI_ISASSIGNABLEFROM_ENTRY(env, sub, super);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   579
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  oop sub_mirror   = JNIHandles::resolve_non_null(sub);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  oop super_mirror = JNIHandles::resolve_non_null(super);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
  if (java_lang_Class::is_primitive(sub_mirror) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
      java_lang_Class::is_primitive(super_mirror)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
    jboolean ret = (sub_mirror == super_mirror);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   585
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   586
    HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   589
  Klass* sub_klass   = java_lang_Class::as_Klass(sub_mirror);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   590
  Klass* super_klass = java_lang_Class::as_Klass(super_mirror);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  assert(sub_klass != NULL && super_klass != NULL, "invalid arguments to jni_IsAssignableFrom");
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   592
  jboolean ret = sub_klass->is_subtype_of(super_klass) ?
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
                   JNI_TRUE : JNI_FALSE;
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   594
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   595
  HOTSPOT_JNI_ISASSIGNABLEFROM_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   599
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   600
DT_RETURN_MARK_DECL(Throw, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   601
                    , HOTSPOT_JNI_THROW_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
JNI_ENTRY(jint, jni_Throw(JNIEnv *env, jthrowable obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  JNIWrapper("Throw");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   605
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   606
  HOTSPOT_JNI_THROW_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   607
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  jint ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  DT_RETURN_MARK(Throw, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  THROW_OOP_(JNIHandles::resolve(obj), JNI_OK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
  ShouldNotReachHere();
27679
06b3a53d7781 8064786: Fix debug build after 8062808: Turn on the -Wreturn-type warning
goetz
parents: 27247
diff changeset
   613
  return 0;  // Mute compiler.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   616
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   617
DT_RETURN_MARK_DECL(ThrowNew, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
   618
                    , HOTSPOT_JNI_THROWNEW_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
JNI_ENTRY(jint, jni_ThrowNew(JNIEnv *env, jclass clazz, const char *message))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  JNIWrapper("ThrowNew");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   622
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   623
  HOTSPOT_JNI_THROWNEW_ENTRY(env, clazz, (char *) message);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   624
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  jint ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  DT_RETURN_MARK(ThrowNew, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   628
  InstanceKlass* k = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz)));
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   629
  Symbol*  name = k->name();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
  Handle class_loader (THREAD,  k->class_loader());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  Handle protection_domain (THREAD, k->protection_domain());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
  THROW_MSG_LOADER_(name, (char *)message, class_loader, protection_domain, JNI_OK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
  ShouldNotReachHere();
27679
06b3a53d7781 8064786: Fix debug build after 8062808: Turn on the -Wreturn-type warning
goetz
parents: 27247
diff changeset
   634
  return 0;  // Mute compiler.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
// JNI functions only transform a pending async exception to a synchronous
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
// exception in ExceptionOccurred and ExceptionCheck calls, since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
// delivering an async exception in other places won't change the native
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
// code's control flow and would be harmful when native code further calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
// JNI functions with a pending exception. Async exception is also checked
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
// during the call, so ExceptionOccurred/ExceptionCheck won't return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
// false but deliver the async exception at the very end during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
// state transition.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
static void jni_check_async_exceptions(JavaThread *thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
  assert(thread == Thread::current(), "must be itself");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  thread->check_and_handle_async_exceptions();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
JNI_ENTRY_NO_PRESERVE(jthrowable, jni_ExceptionOccurred(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  JNIWrapper("ExceptionOccurred");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   654
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   655
  HOTSPOT_JNI_EXCEPTIONOCCURRED_ENTRY(env);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   656
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  jni_check_async_exceptions(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  oop exception = thread->pending_exception();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  jthrowable ret = (jthrowable) JNIHandles::make_local(env, exception);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   660
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   661
  HOTSPOT_JNI_EXCEPTIONOCCURRED_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
JNI_ENTRY_NO_PRESERVE(void, jni_ExceptionDescribe(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  JNIWrapper("ExceptionDescribe");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   668
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   669
  HOTSPOT_JNI_EXCEPTIONDESCRIBE_ENTRY(env);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   670
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  if (thread->has_pending_exception()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    Handle ex(thread, thread->pending_exception());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    thread->clear_pending_exception();
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   674
    if (ex->is_a(SystemDictionary::ThreadDeath_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
      // Don't print anything if we are being killed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
      jio_fprintf(defaultStream::error_stream(), "Exception ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
      if (thread != NULL && thread->threadObj() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
        ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
        jio_fprintf(defaultStream::error_stream(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
        "in thread \"%s\" ", thread->get_thread_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      }
4571
80b553bddc26 6914300: ciEnv should export all well known classes
never
parents: 4561
diff changeset
   683
      if (ex->is_a(SystemDictionary::Throwable_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
        JavaValue result(T_VOID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
        JavaCalls::call_virtual(&result,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
                                ex,
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
   687
                                SystemDictionary::Throwable_klass(),
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   688
                                vmSymbols::printStackTrace_name(),
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   689
                                vmSymbols::void_method_signature(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
                                THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
        // If an exception is thrown in the call it gets thrown away. Not much
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
        // we can do with it. The native code that calls this, does not check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
        // for the exception - hence, it might still be in the thread when DestroyVM gets
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
        // called, potentially causing a few asserts to trigger - since no pending exception
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
        // is expected.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
        CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
        ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
        jio_fprintf(defaultStream::error_stream(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
        ". Uncaught exception of type %s.",
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
   701
        ex->klass()->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  }
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   705
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   706
  HOTSPOT_JNI_EXCEPTIONDESCRIBE_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
JNI_QUICK_ENTRY(void, jni_ExceptionClear(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
  JNIWrapper("ExceptionClear");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   712
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   713
  HOTSPOT_JNI_EXCEPTIONCLEAR_ENTRY(env);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  // The jni code might be using this API to clear java thrown exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  // So just mark jvmti thread exception state as exception caught.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  JvmtiThreadState *state = JavaThread::current()->jvmti_thread_state();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
  if (state != NULL && state->is_exception_detected()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
    state->set_exception_caught();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  thread->clear_pending_exception();
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   722
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   723
  HOTSPOT_JNI_EXCEPTIONCLEAR_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
JNI_ENTRY(void, jni_FatalError(JNIEnv *env, const char *msg))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  JNIWrapper("FatalError");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   729
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   730
  HOTSPOT_JNI_FATALERROR_ENTRY(env, (char *) msg);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   731
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  tty->print_cr("FATAL ERROR in native method: %s", msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  thread->print_stack();
773
01daf7c809b1 6694099: Hotspot vm_exit_out_of_memory should dump core
poonam
parents: 360
diff changeset
   734
  os::abort(); // Dump core and abort
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
JNI_ENTRY(jint, jni_PushLocalFrame(JNIEnv *env, jint capacity))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  JNIWrapper("PushLocalFrame");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   740
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   741
  HOTSPOT_JNI_PUSHLOCALFRAME_ENTRY(env, capacity);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   742
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  //%note jni_11
25630
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   744
  if (capacity < 0 ||
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   745
      ((MaxJNILocalCapacity > 0) && (capacity > MaxJNILocalCapacity))) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   746
    HOTSPOT_JNI_PUSHLOCALFRAME_RETURN((uint32_t)JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  JNIHandleBlock* old_handles = thread->active_handles();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  assert(new_handles != NULL, "should not be NULL");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
  new_handles->set_pop_frame_link(old_handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  thread->set_active_handles(new_handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  jint ret = JNI_OK;
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   755
  HOTSPOT_JNI_PUSHLOCALFRAME_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
JNI_ENTRY(jobject, jni_PopLocalFrame(JNIEnv *env, jobject result))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  JNIWrapper("PopLocalFrame");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   762
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   763
  HOTSPOT_JNI_POPLOCALFRAME_ENTRY(env, result);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   764
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  //%note jni_11
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  Handle result_handle(thread, JNIHandles::resolve(result));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
  JNIHandleBlock* old_handles = thread->active_handles();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  JNIHandleBlock* new_handles = old_handles->pop_frame_link();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  if (new_handles != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
    // As a sanity check we only release the handle blocks if the pop_frame_link is not NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
    // This way code will still work if PopLocalFrame is called without a corresponding
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    // PushLocalFrame call. Note that we set the pop_frame_link to NULL explicitly, otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
    // the release_block call will release the blocks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    thread->set_active_handles(new_handles);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
    old_handles->set_pop_frame_link(NULL);              // clear link we won't release new_handles below
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
    JNIHandleBlock::release_block(old_handles, thread); // may block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    result = JNIHandles::make_local(thread, result_handle());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   779
  HOTSPOT_JNI_POPLOCALFRAME_RETURN(result);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
JNI_ENTRY(jobject, jni_NewGlobalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  JNIWrapper("NewGlobalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   786
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   787
  HOTSPOT_JNI_NEWGLOBALREF_ENTRY(env, ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   788
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  Handle ref_handle(thread, JNIHandles::resolve(ref));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  jobject ret = JNIHandles::make_global(ref_handle);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   791
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   792
  HOTSPOT_JNI_NEWGLOBALREF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
// Must be JNI_ENTRY (with HandleMark)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
JNI_ENTRY_NO_PRESERVE(void, jni_DeleteGlobalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  JNIWrapper("DeleteGlobalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   799
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   800
  HOTSPOT_JNI_DELETEGLOBALREF_ENTRY(env, ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   801
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  JNIHandles::destroy_global(ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   803
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   804
  HOTSPOT_JNI_DELETEGLOBALREF_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
JNI_QUICK_ENTRY(void, jni_DeleteLocalRef(JNIEnv *env, jobject obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  JNIWrapper("DeleteLocalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   809
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   810
  HOTSPOT_JNI_DELETELOCALREF_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   811
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  JNIHandles::destroy_local(obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   813
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   814
  HOTSPOT_JNI_DELETELOCALREF_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
JNI_QUICK_ENTRY(jboolean, jni_IsSameObject(JNIEnv *env, jobject r1, jobject r2))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  JNIWrapper("IsSameObject");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   819
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   820
  HOTSPOT_JNI_ISSAMEOBJECT_ENTRY(env, r1, r2);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   821
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  oop a = JNIHandles::resolve(r1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  oop b = JNIHandles::resolve(r2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  jboolean ret = (a == b) ? JNI_TRUE : JNI_FALSE;
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   825
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   826
  HOTSPOT_JNI_ISSAMEOBJECT_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
JNI_ENTRY(jobject, jni_NewLocalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  JNIWrapper("NewLocalRef");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   833
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   834
  HOTSPOT_JNI_NEWLOCALREF_ENTRY(env, ref);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   835
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
  jobject ret = JNIHandles::make_local(env, JNIHandles::resolve(ref));
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   837
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   838
  HOTSPOT_JNI_NEWLOCALREF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
JNI_LEAF(jint, jni_EnsureLocalCapacity(JNIEnv *env, jint capacity))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  JNIWrapper("EnsureLocalCapacity");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   844
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   845
  HOTSPOT_JNI_ENSURELOCALCAPACITY_ENTRY(env, capacity);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   846
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
  jint ret;
25630
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   848
  if (capacity >= 0 &&
ff281ea14d41 8046919: jni_PushLocalFrame OOM - increase MAX_REASONABLE_LOCAL_CAPACITY
dsimms
parents: 25477
diff changeset
   849
      ((MaxJNILocalCapacity <= 0) || (capacity <= MaxJNILocalCapacity))) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
    ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
    ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  }
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   854
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   855
  HOTSPOT_JNI_ENSURELOCALCAPACITY_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
// Return the Handle Type
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
JNI_LEAF(jobjectRefType, jni_GetObjectRefType(JNIEnv *env, jobject obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  JNIWrapper("GetObjectRefType");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   862
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   863
  HOTSPOT_JNI_GETOBJECTREFTYPE_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   864
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
  jobjectRefType ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  if (JNIHandles::is_local_handle(thread, obj) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
      JNIHandles::is_frame_handle(thread, obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
    ret = JNILocalRefType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  else if (JNIHandles::is_global_handle(obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    ret = JNIGlobalRefType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  else if (JNIHandles::is_weak_global_handle(obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    ret = JNIWeakGlobalRefType;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
    ret = JNIInvalidRefType;
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
   875
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
   876
  HOTSPOT_JNI_GETOBJECTREFTYPE_RETURN((void *) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
class JNI_ArgumentPusher : public SignatureIterator {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  JavaCallArguments*  _arguments;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  virtual void get_bool   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  virtual void get_char   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  virtual void get_short  () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  virtual void get_byte   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  virtual void get_int    () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
  virtual void get_long   () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  virtual void get_float  () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  virtual void get_double () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  virtual void get_object () = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   895
  JNI_ArgumentPusher(Symbol* signature) : SignatureIterator(signature) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
    this->_return_type = T_ILLEGAL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
    _arguments = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
  virtual void iterate( uint64_t fingerprint ) = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
  void set_java_argument_object(JavaCallArguments *arguments) { _arguments = arguments; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  inline void do_bool()                     { if (!is_return_type()) get_bool();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  inline void do_char()                     { if (!is_return_type()) get_char();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  inline void do_short()                    { if (!is_return_type()) get_short();  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  inline void do_byte()                     { if (!is_return_type()) get_byte();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  inline void do_int()                      { if (!is_return_type()) get_int();    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  inline void do_long()                     { if (!is_return_type()) get_long();   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  inline void do_float()                    { if (!is_return_type()) get_float();  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  inline void do_double()                   { if (!is_return_type()) get_double(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  inline void do_object(int begin, int end) { if (!is_return_type()) get_object(); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  inline void do_array(int begin, int end)  { if (!is_return_type()) get_object(); } // do_array uses get_object -- there is no get_array
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  inline void do_void()                     { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  JavaCallArguments* arguments()     { return _arguments; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
  void push_receiver(Handle h)       { _arguments->push_oop(h); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
class JNI_ArgumentPusherVaArg : public JNI_ArgumentPusher {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  va_list _ap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   926
  inline void get_bool()   {
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   927
    // Normalize boolean arguments from native code by converting 1-255 to JNI_TRUE and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   928
    // 0 to JNI_FALSE.  Boolean return values from native are normalized the same in
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   929
    // TemplateInterpreterGenerator::generate_result_handler_for and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   930
    // SharedRuntime::generate_native_wrapper.
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   931
    jboolean b = va_arg(_ap, jint);
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   932
    _arguments->push_int((jint)(b == 0 ? JNI_FALSE : JNI_TRUE));
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   933
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  inline void get_char()   { _arguments->push_int(va_arg(_ap, jint)); } // char is coerced to int when using va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  inline void get_short()  { _arguments->push_int(va_arg(_ap, jint)); } // short is coerced to int when using va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  inline void get_byte()   { _arguments->push_int(va_arg(_ap, jint)); } // byte is coerced to int when using va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  inline void get_int()    { _arguments->push_int(va_arg(_ap, jint)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  // each of these paths is exercized by the various jck Call[Static,Nonvirtual,][Void,Int,..]Method[A,V,] tests
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  inline void get_long()   { _arguments->push_long(va_arg(_ap, jlong)); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  inline void get_float()  { _arguments->push_float((jfloat)va_arg(_ap, jdouble)); } // float is coerced to double w/ va_arg
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  inline void get_double() { _arguments->push_double(va_arg(_ap, jdouble)); }
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
   944
  inline void get_object() { _arguments->push_jobject(va_arg(_ap, jobject)); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
  inline void set_ap(va_list rap) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
    va_copy(_ap, rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
 public:
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   951
  JNI_ArgumentPusherVaArg(Symbol* signature, va_list rap)
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   952
       : JNI_ArgumentPusher(signature) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
   955
  JNI_ArgumentPusherVaArg(jmethodID method_id, va_list rap)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   956
      : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)->signature()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  // Optimized path if we have the bitvector form of signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  void iterate( uint64_t fingerprint ) {
27471
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
   962
    if (fingerprint == (uint64_t)CONST64(-1)) {
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
   963
      SignatureIterator::iterate(); // Must be too many arguments
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
   964
    } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
      _return_type = (BasicType)((fingerprint >> static_feature_size) &
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
                                  result_feature_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
      assert(fingerprint, "Fingerprint should not be 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
      fingerprint = fingerprint >> (static_feature_size + result_feature_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
      while ( 1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
        switch ( fingerprint & parameter_feature_mask ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
          case bool_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   973
            get_bool();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   974
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
          case char_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   976
            get_char();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   977
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
          case short_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   979
            get_short();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   980
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
          case byte_parm:
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   982
            get_byte();
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
   983
            break;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
          case int_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
            get_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
          case obj_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
            get_object();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
          case long_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
            get_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
          case float_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
            get_float();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
          case double_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
            get_double();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
          case done_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
            return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
          default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
            ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
        fingerprint >>= parameter_feature_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
class JNI_ArgumentPusherArray : public JNI_ArgumentPusher {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
 protected:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  const jvalue *_ap;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
37483
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1017
  inline void get_bool()   {
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1018
    // Normalize boolean arguments from native code by converting 1-255 to JNI_TRUE and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1019
    // 0 to JNI_FALSE.  Boolean return values from native are normalized the same in
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1020
    // TemplateInterpreterGenerator::generate_result_handler_for and
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1021
    // SharedRuntime::generate_native_wrapper.
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1022
    jboolean b = (_ap++)->z;
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1023
    _arguments->push_int((jint)(b == 0 ? JNI_FALSE : JNI_TRUE));
8447cff6323d 8149170: Better byte behavior should normalize JNI arguments
coleenp
parents: 37480
diff changeset
  1024
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  inline void get_char()   { _arguments->push_int((jint)(_ap++)->c); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  inline void get_short()  { _arguments->push_int((jint)(_ap++)->s); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  inline void get_byte()   { _arguments->push_int((jint)(_ap++)->b); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  inline void get_int()    { _arguments->push_int((jint)(_ap++)->i); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  inline void get_long()   { _arguments->push_long((_ap++)->j);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
  inline void get_float()  { _arguments->push_float((_ap++)->f); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
  inline void get_double() { _arguments->push_double((_ap++)->d);}
44406
a46a6c4d1dd9 8176100: [REDO][REDO] G1 Needs pre barrier on dereference of weak JNI handles
mgerdin
parents: 44093
diff changeset
  1033
  inline void get_object() { _arguments->push_jobject((_ap++)->l); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  inline void set_ap(const jvalue *rap) { _ap = rap; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
 public:
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1038
  JNI_ArgumentPusherArray(Symbol* signature, const jvalue *rap)
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1039
       : JNI_ArgumentPusher(signature) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
  }
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1042
  JNI_ArgumentPusherArray(jmethodID method_id, const jvalue *rap)
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1043
      : JNI_ArgumentPusher(Method::resolve_jmethod_id(method_id)->signature()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
    set_ap(rap);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  // Optimized path if we have the bitvector form of signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
  void iterate( uint64_t fingerprint ) {
27471
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
  1049
    if (fingerprint == (uint64_t)CONST64(-1)) {
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
  1050
      SignatureIterator::iterate(); // Must be too many arguments
6e56277909f1 8062370: Various minor code improvements
goetz
parents: 27247
diff changeset
  1051
    } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
      _return_type = (BasicType)((fingerprint >> static_feature_size) &
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
                                  result_feature_mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
      assert(fingerprint, "Fingerprint should not be 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
      fingerprint = fingerprint >> (static_feature_size + result_feature_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
      while ( 1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
        switch ( fingerprint & parameter_feature_mask ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
          case bool_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
            get_bool();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
          case char_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
            get_char();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
          case short_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
            get_short();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
          case byte_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
            get_byte();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
          case int_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
            get_int();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
          case obj_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
            get_object();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
          case long_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
            get_long();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
          case float_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
            get_float();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
          case double_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
            get_double();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
          case done_parm:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
            return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
          default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
            ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
            break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
        fingerprint >>= parameter_feature_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
enum JNICallType {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
  JNI_STATIC,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  JNI_VIRTUAL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
  JNI_NONVIRTUAL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
static void jni_invoke_static(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1108
  methodHandle method(THREAD, Method::resolve_jmethod_id(method_id));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  // Create object to hold arguments for the JavaCall, and associate it with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
  // the jni parser
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  int number_of_parameters = method->size_of_parameters();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  JavaCallArguments java_args(number_of_parameters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
  args->set_java_argument_object(&java_args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
  assert(method->is_static(), "method should be static");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
  // Fill out JavaCallArguments object
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1120
  args->iterate( Fingerprinter(method).fingerprint() );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
  // Initialize result type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  result->set_type(args->get_ret_type());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
  // Invoke the method. Result is returned as oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  JavaCalls::call(result, method, &java_args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
  // Convert result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
  if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
    result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
static void jni_invoke_nonstatic(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1135
  oop recv = JNIHandles::resolve(receiver);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1136
  if (recv == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
    THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
  Handle h_recv(THREAD, recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  int number_of_parameters;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1142
  Method* selected_method;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1144
    Method* m = Method::resolve_jmethod_id(method_id);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
    number_of_parameters = m->size_of_parameters();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1146
    Klass* holder = m->method_holder();
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1147
    if (call_type != JNI_VIRTUAL) {
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1148
        selected_method = m;
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1149
    } else if (!m->has_itable_index()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
      // non-interface call -- for that little speed boost, don't handlize
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  1151
      debug_only(NoSafepointVerifier nosafepoint;)
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1152
      // jni_GetMethodID makes sure class is linked and initialized
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1153
      // so m should have a valid vtable index.
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1154
      assert(m->valid_vtable_index(), "no valid vtable index");
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1155
      int vtbl_index = m->vtable_index();
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1156
      if (vtbl_index != Method::nonvirtual_vtable_index) {
35900
d64cf9290fc4 8148481: Devirtualize Klass::vtable
mgerdin
parents: 35519
diff changeset
  1157
        selected_method = h_recv->klass()->method_at_vtable(vtbl_index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
      } else {
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1159
        // final method
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
        selected_method = m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
      // interface call
31027
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1164
      int itbl_index = m->itable_index();
6df6a1332f23 8072588: JVM crashes in JNI if toString is declared as an interface method
aeriksso
parents: 30764
diff changeset
  1165
      Klass* k = h_recv->klass();
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1166
      selected_method = InstanceKlass::cast(k)->method_at_itable(holder, itbl_index, CHECK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  methodHandle method(THREAD, selected_method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1171
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
  // Create object to hold arguments for the JavaCall, and associate it with
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
  // the jni parser
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
  ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  JavaCallArguments java_args(number_of_parameters);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
  args->set_java_argument_object(&java_args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
  // handle arguments
41669
2091069b6851 8081800: AbstractMethodError when evaluating a private method in an interface via debugger
dholmes
parents: 40655
diff changeset
  1179
  assert(!method->is_static(), "method %s should not be static", method->name_and_sig_as_C_string());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
  args->push_receiver(h_recv); // Push jobject handle
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  // Fill out JavaCallArguments object
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1183
  args->iterate( Fingerprinter(method).fingerprint() );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  // Initialize result type
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  result->set_type(args->get_ret_type());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
  // Invoke the method. Result is returned as oop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  JavaCalls::call(result, method, &java_args, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  // Convert result
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
  if (result->get_type() == T_OBJECT || result->get_type() == T_ARRAY) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
    result->set_jobject(JNIHandles::make_local(env, (oop) result->get_jobject()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
static instanceOop alloc_object(jclass clazz, TRAPS) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1198
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
22532
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1199
  if (k == NULL) {
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1200
    ResourceMark rm(THREAD);
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1201
    THROW_(vmSymbols::java_lang_InstantiationException(), NULL);
1fc87ea15795 8031427: AllocObject and Unsafe.allocateInstance segfault for primitive types
gdub
parents: 22520
diff changeset
  1202
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1203
  k->check_valid_for_instantiation(false, CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1204
  k->initialize(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1205
  instanceOop ih = InstanceKlass::cast(k)->allocate_instance(THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
  return ih;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1209
DT_RETURN_MARK_DECL(AllocObject, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1210
                    , HOTSPOT_JNI_ALLOCOBJECT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
JNI_ENTRY(jobject, jni_AllocObject(JNIEnv *env, jclass clazz))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  JNIWrapper("AllocObject");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1215
  HOTSPOT_JNI_ALLOCOBJECT_ENTRY(env, clazz);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1216
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
  DT_RETURN_MARK(AllocObject, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
  ret = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1225
DT_RETURN_MARK_DECL(NewObjectA, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1226
                    , HOTSPOT_JNI_NEWOBJECTA_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
JNI_ENTRY(jobject, jni_NewObjectA(JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
  JNIWrapper("NewObjectA");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1230
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1231
  HOTSPOT_JNI_NEWOBJECTA_ENTRY(env, clazz, (uintptr_t) methodID);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1232
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
  jobject obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  DT_RETURN_MARK(NewObjectA, jobject, (const jobject)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
  obj = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1239
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1244
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1245
DT_RETURN_MARK_DECL(NewObjectV, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1246
                    , HOTSPOT_JNI_NEWOBJECTV_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
JNI_ENTRY(jobject, jni_NewObjectV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
  JNIWrapper("NewObjectV");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1250
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1251
  HOTSPOT_JNI_NEWOBJECTV_ENTRY(env, clazz, (uintptr_t) methodID);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1252
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  jobject obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  DT_RETURN_MARK(NewObjectV, jobject, (const jobject&)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
  obj = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1259
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1264
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1265
DT_RETURN_MARK_DECL(NewObject, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1266
                    , HOTSPOT_JNI_NEWOBJECT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
JNI_ENTRY(jobject, jni_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
  JNIWrapper("NewObject");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1270
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1271
  HOTSPOT_JNI_NEWOBJECT_ENTRY(env, clazz, (uintptr_t) methodID);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1272
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
  jobject obj = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
  DT_RETURN_MARK(NewObject, jobject, (const jobject&)obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
  instanceOop i = alloc_object(clazz, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
  obj = JNIHandles::make_local(env, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1281
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
  return obj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
JNI_ENTRY(jclass, jni_GetObjectClass(JNIEnv *env, jobject obj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
  JNIWrapper("GetObjectClass");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1290
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1291
  HOTSPOT_JNI_GETOBJECTCLASS_ENTRY(env, obj);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1292
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1293
  Klass* k = JNIHandles::resolve_non_null(obj)->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
  jclass ret =
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14391
diff changeset
  1295
    (jclass) JNIHandles::make_local(env, k->java_mirror());
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1296
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1297
  HOTSPOT_JNI_GETOBJECTCLASS_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
JNI_QUICK_ENTRY(jboolean, jni_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1302
  JNIWrapper("IsInstanceOf");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1303
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1304
  HOTSPOT_JNI_ISINSTANCEOF_ENTRY(env, obj, clazz);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1305
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
  jboolean ret = JNI_TRUE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
  if (obj != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
    ret = JNI_FALSE;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1309
    Klass* k = java_lang_Class::as_Klass(
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
      JNIHandles::resolve_non_null(clazz));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
    if (k != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
      ret = JNIHandles::resolve_non_null(obj)->is_a(k) ? JNI_TRUE : JNI_FALSE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  }
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  1315
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1316
  HOTSPOT_JNI_ISINSTANCEOF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
static jmethodID get_method_id(JNIEnv *env, jclass clazz, const char *name_str,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
                               const char *sig, bool is_static, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  // %%%% This code should probably just call into a method in the LinkResolver
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
  // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
  // passed in) so the method and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  // table.  If they're not there, the method doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1328
  const char *name_to_probe = (name_str == NULL)
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1329
                        ? vmSymbols::object_initializer_name()->as_C_string()
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1330
                        : name_str;
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1331
  TempNewSymbol name = SymbolTable::probe(name_to_probe, (int)strlen(name_to_probe));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1332
  TempNewSymbol signature = SymbolTable::probe(sig, (int)strlen(sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1333
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1334
  if (name == NULL || signature == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
    THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
  // Throw a NoSuchMethodError exception if we have an instance of a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
  // primitive java.lang.Class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
  if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(clazz))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
    THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1344
  Klass* klass = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
  // Make sure class is linked and initialized before handing id's out to
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1347
  // Method*s.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1348
  klass->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  1350
  Method* m;
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1351
  if (name == vmSymbols::object_initializer_name() ||
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1352
      name == vmSymbols::class_initializer_name()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
    // Never search superclasses for constructors
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
  1354
    if (klass->is_instance_klass()) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1355
      m = InstanceKlass::cast(klass)->find_method(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
      m = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  } else {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1360
    m = klass->lookup_method(name, signature);
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
  1361
    if (m == NULL &&  klass->is_instance_klass()) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1362
      m = InstanceKlass::cast(klass)->lookup_method_in_ordered_interfaces(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
  if (m == NULL || (m->is_static() != is_static)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
    THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), name_str);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  return m->jmethod_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
JNI_ENTRY(jmethodID, jni_GetMethodID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
  JNIWrapper("GetMethodID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1375
  HOTSPOT_JNI_GETMETHODID_ENTRY(env, clazz, (char *) name, (char *) sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
  jmethodID ret = get_method_id(env, clazz, name, sig, false, thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1377
  HOTSPOT_JNI_GETMETHODID_RETURN((uintptr_t) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
JNI_ENTRY(jmethodID, jni_GetStaticMethodID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
  JNIWrapper("GetStaticMethodID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1385
  HOTSPOT_JNI_GETSTATICMETHODID_ENTRY(env, (char *) clazz, (char *) name, (char *)sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
  jmethodID ret = get_method_id(env, clazz, name, sig, true, thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1387
  HOTSPOT_JNI_GETSTATICMETHODID_RETURN((uintptr_t) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
// Calling Methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1397
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1398
#define DEFINE_CALLMETHOD(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1399
                          , EntryProbe, ReturnProbe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1400
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1401
  DT_RETURN_MARK_DECL_FOR(Result, Call##Result##Method, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1402
                          , ReturnProbe);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1403
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1404
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1405
          jni_Call##Result##Method(JNIEnv *env, jobject obj, jmethodID methodID, ...)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1406
  JNIWrapper("Call" XSTR(Result) "Method"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1407
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1408
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1409
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1410
  DT_RETURN_MARK_FOR(Result, Call##Result##Method, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1411
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1412
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1413
  va_list args; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1414
  va_start(args, methodID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1415
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1416
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1417
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1418
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1419
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1420
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1421
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1422
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1423
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1424
DEFINE_CALLMETHOD(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1425
                  , HOTSPOT_JNI_CALLBOOLEANMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1426
                  HOTSPOT_JNI_CALLBOOLEANMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1427
DEFINE_CALLMETHOD(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1428
                  , HOTSPOT_JNI_CALLBYTEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1429
                  HOTSPOT_JNI_CALLBYTEMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1430
DEFINE_CALLMETHOD(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1431
                  , HOTSPOT_JNI_CALLCHARMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1432
                  HOTSPOT_JNI_CALLCHARMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1433
DEFINE_CALLMETHOD(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1434
                  , HOTSPOT_JNI_CALLSHORTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1435
                  HOTSPOT_JNI_CALLSHORTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1436
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1437
DEFINE_CALLMETHOD(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1438
                  , HOTSPOT_JNI_CALLOBJECTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1439
                  HOTSPOT_JNI_CALLOBJECTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1440
DEFINE_CALLMETHOD(jint,     Int,     T_INT,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1441
                  HOTSPOT_JNI_CALLINTMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1442
                  HOTSPOT_JNI_CALLINTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1443
DEFINE_CALLMETHOD(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1444
                  , HOTSPOT_JNI_CALLLONGMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1445
                  HOTSPOT_JNI_CALLLONGMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1446
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1447
DEFINE_CALLMETHOD(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1448
                  , HOTSPOT_JNI_CALLFLOATMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1449
                  HOTSPOT_JNI_CALLFLOATMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1450
DEFINE_CALLMETHOD(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1451
                  , HOTSPOT_JNI_CALLDOUBLEMETHOD_ENTRY(env, obj, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1452
                  HOTSPOT_JNI_CALLDOUBLEMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1453
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1454
#define DEFINE_CALLMETHODV(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1455
                          , EntryProbe, ReturnProbe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1456
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1457
  DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodV, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1458
                          , ReturnProbe);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1459
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1460
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1461
          jni_Call##Result##MethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1462
  JNIWrapper("Call" XSTR(Result) "MethodV"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1463
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1464
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1465
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1466
  DT_RETURN_MARK_FOR(Result, Call##Result##MethodV, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1467
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1468
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1469
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1470
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1471
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1472
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1473
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1474
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1475
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1476
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1477
DEFINE_CALLMETHODV(jboolean, Boolean, T_BOOLEAN
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1478
                  , HOTSPOT_JNI_CALLBOOLEANMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1479
                  HOTSPOT_JNI_CALLBOOLEANMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1480
DEFINE_CALLMETHODV(jbyte,    Byte,    T_BYTE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1481
                  , HOTSPOT_JNI_CALLBYTEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1482
                  HOTSPOT_JNI_CALLBYTEMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1483
DEFINE_CALLMETHODV(jchar,    Char,    T_CHAR
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1484
                  , HOTSPOT_JNI_CALLCHARMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1485
                  HOTSPOT_JNI_CALLCHARMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1486
DEFINE_CALLMETHODV(jshort,   Short,   T_SHORT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1487
                  , HOTSPOT_JNI_CALLSHORTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1488
                  HOTSPOT_JNI_CALLSHORTMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1489
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1490
DEFINE_CALLMETHODV(jobject,  Object,  T_OBJECT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1491
                  , HOTSPOT_JNI_CALLOBJECTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1492
                  HOTSPOT_JNI_CALLOBJECTMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1493
DEFINE_CALLMETHODV(jint,     Int,     T_INT,
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1494
                  HOTSPOT_JNI_CALLINTMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1495
                  HOTSPOT_JNI_CALLINTMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1496
DEFINE_CALLMETHODV(jlong,    Long,    T_LONG
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1497
                  , HOTSPOT_JNI_CALLLONGMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1498
                  HOTSPOT_JNI_CALLLONGMETHODV_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1499
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1500
DEFINE_CALLMETHODV(jfloat,   Float,   T_FLOAT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1501
                  , HOTSPOT_JNI_CALLFLOATMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1502
                  HOTSPOT_JNI_CALLFLOATMETHODV_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1503
DEFINE_CALLMETHODV(jdouble,  Double,  T_DOUBLE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1504
                  , HOTSPOT_JNI_CALLDOUBLEMETHODV_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1505
                  HOTSPOT_JNI_CALLDOUBLEMETHODV_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1506
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1507
#define DEFINE_CALLMETHODA(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1508
                          , EntryProbe, ReturnProbe)    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1509
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1510
  DT_RETURN_MARK_DECL_FOR(Result, Call##Result##MethodA, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1511
                          , ReturnProbe);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1512
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1513
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1514
          jni_Call##Result##MethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1515
  JNIWrapper("Call" XSTR(Result) "MethodA"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1516
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1517
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1518
  DT_RETURN_MARK_FOR(Result, Call##Result##MethodA, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1519
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1520
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1521
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1522
  JNI_ArgumentPusherArray ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1523
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1524
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1525
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1526
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1527
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1528
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1529
DEFINE_CALLMETHODA(jboolean, Boolean, T_BOOLEAN
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1530
                  , HOTSPOT_JNI_CALLBOOLEANMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1531
                  HOTSPOT_JNI_CALLBOOLEANMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1532
DEFINE_CALLMETHODA(jbyte,    Byte,    T_BYTE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1533
                  , HOTSPOT_JNI_CALLBYTEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1534
                  HOTSPOT_JNI_CALLBYTEMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1535
DEFINE_CALLMETHODA(jchar,    Char,    T_CHAR
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1536
                  , HOTSPOT_JNI_CALLCHARMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1537
                  HOTSPOT_JNI_CALLCHARMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1538
DEFINE_CALLMETHODA(jshort,   Short,   T_SHORT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1539
                  , HOTSPOT_JNI_CALLSHORTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1540
                  HOTSPOT_JNI_CALLSHORTMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1541
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1542
DEFINE_CALLMETHODA(jobject,  Object,  T_OBJECT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1543
                  , HOTSPOT_JNI_CALLOBJECTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1544
                  HOTSPOT_JNI_CALLOBJECTMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1545
DEFINE_CALLMETHODA(jint,     Int,     T_INT,
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1546
                  HOTSPOT_JNI_CALLINTMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1547
                  HOTSPOT_JNI_CALLINTMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1548
DEFINE_CALLMETHODA(jlong,    Long,    T_LONG
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1549
                  , HOTSPOT_JNI_CALLLONGMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1550
                  HOTSPOT_JNI_CALLLONGMETHODA_RETURN(_ret_ref))
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1551
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1552
DEFINE_CALLMETHODA(jfloat,   Float,   T_FLOAT
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1553
                  , HOTSPOT_JNI_CALLFLOATMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1554
                  HOTSPOT_JNI_CALLFLOATMETHODA_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1555
DEFINE_CALLMETHODA(jdouble,  Double,  T_DOUBLE
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1556
                  , HOTSPOT_JNI_CALLDOUBLEMETHODA_ENTRY(env, obj, (uintptr_t)methodID),
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  1557
                  HOTSPOT_JNI_CALLDOUBLEMETHODA_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1558
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1559
DT_VOID_RETURN_MARK_DECL(CallVoidMethod, HOTSPOT_JNI_CALLVOIDMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1560
DT_VOID_RETURN_MARK_DECL(CallVoidMethodV, HOTSPOT_JNI_CALLVOIDMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1561
DT_VOID_RETURN_MARK_DECL(CallVoidMethodA, HOTSPOT_JNI_CALLVOIDMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1562
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1563
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
JNI_ENTRY(void, jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
  JNIWrapper("CallVoidMethod");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1566
  HOTSPOT_JNI_CALLVOIDMETHOD_ENTRY(env, obj, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
  DT_VOID_RETURN_MARK(CallVoidMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1572
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
JNI_ENTRY(void, jni_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
  JNIWrapper("CallVoidMethodV");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1580
  HOTSPOT_JNI_CALLVOIDMETHODV_ENTRY(env, obj, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
  DT_VOID_RETURN_MARK(CallVoidMethodV);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1584
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
JNI_ENTRY(void, jni_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
  JNIWrapper("CallVoidMethodA");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1591
  HOTSPOT_JNI_CALLVOIDMETHODA_ENTRY(env, obj, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
  DT_VOID_RETURN_MARK(CallVoidMethodA);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1595
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_VIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1600
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1601
#define DEFINE_CALLNONVIRTUALMETHOD(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1602
                                    , EntryProbe, ReturnProbe)      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1603
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1604
  DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##Method, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1605
                          , ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1606
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1607
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1608
          jni_CallNonvirtual##Result##Method(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1609
  JNIWrapper("CallNonvitual" XSTR(Result) "Method"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1610
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1611
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1612
  ResultType ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1613
  DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##Method, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1614
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1615
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1616
  va_list args; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1617
  va_start(args, methodID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1618
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1619
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1620
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1621
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1622
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1623
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1624
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1625
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1626
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1627
DEFINE_CALLNONVIRTUALMETHOD(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1628
                            , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1629
                            HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1630
DEFINE_CALLNONVIRTUALMETHOD(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1631
                            , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1632
                            HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1633
DEFINE_CALLNONVIRTUALMETHOD(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1634
                            , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1635
                            HOTSPOT_JNI_CALLNONVIRTUALCHARMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1636
DEFINE_CALLNONVIRTUALMETHOD(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1637
                            , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1638
                            HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1639
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1640
DEFINE_CALLNONVIRTUALMETHOD(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1641
                            , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1642
                            HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1643
DEFINE_CALLNONVIRTUALMETHOD(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1644
                            , HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1645
                            HOTSPOT_JNI_CALLNONVIRTUALINTMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1646
DEFINE_CALLNONVIRTUALMETHOD(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1647
                            , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1648
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1649
                            HOTSPOT_JNI_CALLNONVIRTUALLONGMETHOD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1650
DEFINE_CALLNONVIRTUALMETHOD(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1651
                            , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1652
                            HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1653
DEFINE_CALLNONVIRTUALMETHOD(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1654
                            , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1655
                            HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHOD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1656
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1657
#define DEFINE_CALLNONVIRTUALMETHODV(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1658
                                    , EntryProbe, ReturnProbe)      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1659
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1660
  DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodV, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1661
                          , ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1662
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1663
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1664
          jni_CallNonvirtual##Result##MethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1665
  JNIWrapper("CallNonvitual" XSTR(Result) "MethodV"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1666
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1667
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1668
  ResultType ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1669
  DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodV, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1670
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1671
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1672
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1673
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1674
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1675
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1676
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1677
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1678
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1679
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1680
DEFINE_CALLNONVIRTUALMETHODV(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1681
                            , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1682
                            HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1683
DEFINE_CALLNONVIRTUALMETHODV(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1684
                            , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1685
                            HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1686
DEFINE_CALLNONVIRTUALMETHODV(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1687
                            , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1688
                            HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1689
DEFINE_CALLNONVIRTUALMETHODV(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1690
                            , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1691
                            HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1692
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1693
DEFINE_CALLNONVIRTUALMETHODV(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1694
                            , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1695
                            HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1696
DEFINE_CALLNONVIRTUALMETHODV(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1697
                            , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1698
                            HOTSPOT_JNI_CALLNONVIRTUALINTMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1699
DEFINE_CALLNONVIRTUALMETHODV(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1700
                            , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1701
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1702
                            HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODV_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1703
DEFINE_CALLNONVIRTUALMETHODV(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1704
                            , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1705
                            HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODV_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1706
DEFINE_CALLNONVIRTUALMETHODV(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1707
                            , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1708
                            HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODV_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1709
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1710
#define DEFINE_CALLNONVIRTUALMETHODA(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1711
                                    , EntryProbe, ReturnProbe)      \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1712
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1713
  DT_RETURN_MARK_DECL_FOR(Result, CallNonvirtual##Result##MethodA, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1714
                          , ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1715
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1716
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1717
          jni_CallNonvirtual##Result##MethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1718
  JNIWrapper("CallNonvitual" XSTR(Result) "MethodA"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1719
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1720
  EntryProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1721
  ResultType ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1722
  DT_RETURN_MARK_FOR(Result, CallNonvirtual##Result##MethodA, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1723
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1724
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1725
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1726
  JNI_ArgumentPusherArray ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1727
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1728
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1729
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1730
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1731
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1732
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1733
DEFINE_CALLNONVIRTUALMETHODA(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1734
                            , HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1735
                            HOTSPOT_JNI_CALLNONVIRTUALBOOLEANMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1736
DEFINE_CALLNONVIRTUALMETHODA(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1737
                            , HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1738
                            HOTSPOT_JNI_CALLNONVIRTUALBYTEMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1739
DEFINE_CALLNONVIRTUALMETHODA(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1740
                            , HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1741
                            HOTSPOT_JNI_CALLNONVIRTUALCHARMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1742
DEFINE_CALLNONVIRTUALMETHODA(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1743
                            , HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1744
                            HOTSPOT_JNI_CALLNONVIRTUALSHORTMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1745
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1746
DEFINE_CALLNONVIRTUALMETHODA(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1747
                            , HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1748
                            HOTSPOT_JNI_CALLNONVIRTUALOBJECTMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1749
DEFINE_CALLNONVIRTUALMETHODA(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1750
                            , HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1751
                            HOTSPOT_JNI_CALLNONVIRTUALINTMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1752
DEFINE_CALLNONVIRTUALMETHODA(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1753
                            , HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1754
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1755
                            HOTSPOT_JNI_CALLNONVIRTUALLONGMETHODA_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1756
DEFINE_CALLNONVIRTUALMETHODA(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1757
                            , HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1758
                            HOTSPOT_JNI_CALLNONVIRTUALFLOATMETHODA_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1759
DEFINE_CALLNONVIRTUALMETHODA(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1760
                            , HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_ENTRY(env, obj, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1761
                            HOTSPOT_JNI_CALLNONVIRTUALDOUBLEMETHODA_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1762
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1763
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethod
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1764
                         , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1765
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodV
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1766
                         , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1767
DT_VOID_RETURN_MARK_DECL(CallNonvirtualVoidMethodA
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1768
                         , HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1769
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
JNI_ENTRY(void, jni_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1771
  JNIWrapper("CallNonvirtualVoidMethod");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1772
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1773
  HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHOD_ENTRY(env, obj, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1774
  DT_VOID_RETURN_MARK(CallNonvirtualVoidMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1775
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1776
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1777
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1778
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1779
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1780
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1781
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1782
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1783
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1784
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1785
JNI_ENTRY(void, jni_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1786
  JNIWrapper("CallNonvirtualVoidMethodV");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1787
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1788
  HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODV_ENTRY(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1789
               env, obj, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
  DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodV);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1793
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
JNI_ENTRY(void, jni_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass cls, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
  JNIWrapper("CallNonvirtualVoidMethodA");
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1800
  HOTSPOT_JNI_CALLNONVIRTUALVOIDMETHODA_ENTRY(
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1801
                env, obj, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
  DT_VOID_RETURN_MARK(CallNonvirtualVoidMethodA);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1804
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
  jni_invoke_nonstatic(env, &jvalue, obj, JNI_NONVIRTUAL, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1809
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1810
#define DEFINE_CALLSTATICMETHOD(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1811
                                , EntryProbe, ResultProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1812
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1813
  DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##Method, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1814
                          , ResultProbe);                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1815
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1816
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1817
          jni_CallStatic##Result##Method(JNIEnv *env, jclass cls, jmethodID methodID, ...)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1818
  JNIWrapper("CallStatic" XSTR(Result) "Method"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1819
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1820
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1821
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1822
  DT_RETURN_MARK_FOR(Result, CallStatic##Result##Method, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1823
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1824
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1825
  va_list args; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1826
  va_start(args, methodID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1827
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1828
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1829
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1830
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1831
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1832
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1833
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1834
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1835
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1836
DEFINE_CALLSTATICMETHOD(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1837
                        , HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1838
                        HOTSPOT_JNI_CALLSTATICBOOLEANMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1839
DEFINE_CALLSTATICMETHOD(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1840
                        , HOTSPOT_JNI_CALLSTATICBYTEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1841
                        HOTSPOT_JNI_CALLSTATICBYTEMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1842
DEFINE_CALLSTATICMETHOD(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1843
                        , HOTSPOT_JNI_CALLSTATICCHARMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1844
                        HOTSPOT_JNI_CALLSTATICCHARMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1845
DEFINE_CALLSTATICMETHOD(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1846
                        , HOTSPOT_JNI_CALLSTATICSHORTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1847
                        HOTSPOT_JNI_CALLSTATICSHORTMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1848
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1849
DEFINE_CALLSTATICMETHOD(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1850
                        , HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1851
                        HOTSPOT_JNI_CALLSTATICOBJECTMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1852
DEFINE_CALLSTATICMETHOD(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1853
                        , HOTSPOT_JNI_CALLSTATICINTMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1854
                        HOTSPOT_JNI_CALLSTATICINTMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1855
DEFINE_CALLSTATICMETHOD(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1856
                        , HOTSPOT_JNI_CALLSTATICLONGMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1857
                        HOTSPOT_JNI_CALLSTATICLONGMETHOD_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1858
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1859
DEFINE_CALLSTATICMETHOD(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1860
                        , HOTSPOT_JNI_CALLSTATICFLOATMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1861
                        HOTSPOT_JNI_CALLSTATICFLOATMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1862
DEFINE_CALLSTATICMETHOD(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1863
                        , HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1864
                        HOTSPOT_JNI_CALLSTATICDOUBLEMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1865
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1866
#define DEFINE_CALLSTATICMETHODV(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1867
                                , EntryProbe, ResultProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1868
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1869
  DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodV, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1870
                          , ResultProbe);                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1871
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1872
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1873
          jni_CallStatic##Result##MethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1874
  JNIWrapper("CallStatic" XSTR(Result) "MethodV"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1875
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1876
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1877
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1878
  DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodV, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1879
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1880
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1881
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1882
  JNI_ArgumentPusherVaArg ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1883
  /* Make sure class is initialized before trying to invoke its method */ \
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1884
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); \
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  1885
  k->initialize(CHECK_0); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1886
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1887
  va_end(args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1888
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1889
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1890
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1891
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1892
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1893
DEFINE_CALLSTATICMETHODV(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1894
                        , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1895
                        HOTSPOT_JNI_CALLSTATICBOOLEANMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1896
DEFINE_CALLSTATICMETHODV(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1897
                        , HOTSPOT_JNI_CALLSTATICBYTEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1898
                        HOTSPOT_JNI_CALLSTATICBYTEMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1899
DEFINE_CALLSTATICMETHODV(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1900
                        , HOTSPOT_JNI_CALLSTATICCHARMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1901
                        HOTSPOT_JNI_CALLSTATICCHARMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1902
DEFINE_CALLSTATICMETHODV(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1903
                        , HOTSPOT_JNI_CALLSTATICSHORTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1904
                        HOTSPOT_JNI_CALLSTATICSHORTMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1905
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1906
DEFINE_CALLSTATICMETHODV(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1907
                        , HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1908
                        HOTSPOT_JNI_CALLSTATICOBJECTMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1909
DEFINE_CALLSTATICMETHODV(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1910
                        , HOTSPOT_JNI_CALLSTATICINTMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1911
                        HOTSPOT_JNI_CALLSTATICINTMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1912
DEFINE_CALLSTATICMETHODV(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1913
                        , HOTSPOT_JNI_CALLSTATICLONGMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1914
                        HOTSPOT_JNI_CALLSTATICLONGMETHODV_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1915
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1916
DEFINE_CALLSTATICMETHODV(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1917
                        , HOTSPOT_JNI_CALLSTATICFLOATMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1918
                        HOTSPOT_JNI_CALLSTATICFLOATMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1919
DEFINE_CALLSTATICMETHODV(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1920
                        , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1921
                        HOTSPOT_JNI_CALLSTATICDOUBLEMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1922
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1923
#define DEFINE_CALLSTATICMETHODA(ResultType, Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1924
                                , EntryProbe, ResultProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1925
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1926
  DT_RETURN_MARK_DECL_FOR(Result, CallStatic##Result##MethodA, ResultType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1927
                          , ResultProbe);                               \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1928
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1929
JNI_ENTRY(ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1930
          jni_CallStatic##Result##MethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1931
  JNIWrapper("CallStatic" XSTR(Result) "MethodA"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1932
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1933
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1934
  ResultType ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1935
  DT_RETURN_MARK_FOR(Result, CallStatic##Result##MethodA, ResultType, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1936
                     (const ResultType&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1937
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1938
  JavaValue jvalue(Tag); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1939
  JNI_ArgumentPusherArray ap(methodID, args); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1940
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1941
  ret = jvalue.get_##ResultType(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1942
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1943
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1944
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1945
// the runtime type of subword integral basic types is integer
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1946
DEFINE_CALLSTATICMETHODA(jboolean, Boolean, T_BOOLEAN
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1947
                        , HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1948
                        HOTSPOT_JNI_CALLSTATICBOOLEANMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1949
DEFINE_CALLSTATICMETHODA(jbyte,    Byte,    T_BYTE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1950
                        , HOTSPOT_JNI_CALLSTATICBYTEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1951
                        HOTSPOT_JNI_CALLSTATICBYTEMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1952
DEFINE_CALLSTATICMETHODA(jchar,    Char,    T_CHAR
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1953
                        , HOTSPOT_JNI_CALLSTATICCHARMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1954
                        HOTSPOT_JNI_CALLSTATICCHARMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1955
DEFINE_CALLSTATICMETHODA(jshort,   Short,   T_SHORT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1956
                        , HOTSPOT_JNI_CALLSTATICSHORTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1957
                        HOTSPOT_JNI_CALLSTATICSHORTMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1958
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1959
DEFINE_CALLSTATICMETHODA(jobject,  Object,  T_OBJECT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1960
                        , HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1961
                        HOTSPOT_JNI_CALLSTATICOBJECTMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1962
DEFINE_CALLSTATICMETHODA(jint,     Int,     T_INT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1963
                        , HOTSPOT_JNI_CALLSTATICINTMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1964
                        HOTSPOT_JNI_CALLSTATICINTMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1965
DEFINE_CALLSTATICMETHODA(jlong,    Long,    T_LONG
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1966
                        , HOTSPOT_JNI_CALLSTATICLONGMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1967
                        HOTSPOT_JNI_CALLSTATICLONGMETHODA_RETURN(_ret_ref));
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1968
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1969
DEFINE_CALLSTATICMETHODA(jfloat,   Float,   T_FLOAT
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1970
                        , HOTSPOT_JNI_CALLSTATICFLOATMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1971
                        HOTSPOT_JNI_CALLSTATICFLOATMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1972
DEFINE_CALLSTATICMETHODA(jdouble,  Double,  T_DOUBLE
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1973
                        , HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_ENTRY(env, cls, (uintptr_t)methodID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1974
                        HOTSPOT_JNI_CALLSTATICDOUBLEMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1975
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1976
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethod
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1977
                         , HOTSPOT_JNI_CALLSTATICVOIDMETHOD_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1978
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodV
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1979
                         , HOTSPOT_JNI_CALLSTATICVOIDMETHODV_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1980
DT_VOID_RETURN_MARK_DECL(CallStaticVoidMethodA
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1981
                         , HOTSPOT_JNI_CALLSTATICVOIDMETHODA_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  1982
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1983
JNI_ENTRY(void, jni_CallStaticVoidMethod(JNIEnv *env, jclass cls, jmethodID methodID, ...))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1984
  JNIWrapper("CallStaticVoidMethod");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1985
  HOTSPOT_JNI_CALLSTATICVOIDMETHOD_ENTRY(env, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1986
  DT_VOID_RETURN_MARK(CallStaticVoidMethod);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1987
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1988
  va_list args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1989
  va_start(args, methodID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1990
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  1991
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1992
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1993
  va_end(args);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1994
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1995
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1996
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1997
JNI_ENTRY(void, jni_CallStaticVoidMethodV(JNIEnv *env, jclass cls, jmethodID methodID, va_list args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1998
  JNIWrapper("CallStaticVoidMethodV");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  1999
  HOTSPOT_JNI_CALLSTATICVOIDMETHODV_ENTRY(env, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2000
  DT_VOID_RETURN_MARK(CallStaticVoidMethodV);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2002
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2003
  JNI_ArgumentPusherVaArg ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2004
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2005
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2007
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2008
JNI_ENTRY(void, jni_CallStaticVoidMethodA(JNIEnv *env, jclass cls, jmethodID methodID, const jvalue *args))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2009
  JNIWrapper("CallStaticVoidMethodA");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2010
  HOTSPOT_JNI_CALLSTATICVOIDMETHODA_ENTRY(env, cls, (uintptr_t) methodID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2011
  DT_VOID_RETURN_MARK(CallStaticVoidMethodA);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2012
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2013
  JavaValue jvalue(T_VOID);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2014
  JNI_ArgumentPusherArray ap(methodID, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2015
  jni_invoke_static(env, &jvalue, NULL, JNI_STATIC, methodID, &ap, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2016
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2018
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2019
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2020
// Accessing Fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2021
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2023
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2024
DT_RETURN_MARK_DECL(GetFieldID, jfieldID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2025
                    , HOTSPOT_JNI_GETFIELDID_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2026
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2027
JNI_ENTRY(jfieldID, jni_GetFieldID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2028
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2029
  JNIWrapper("GetFieldID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2030
  HOTSPOT_JNI_GETFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2031
  jfieldID ret = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2032
  DT_RETURN_MARK(GetFieldID, jfieldID, (const jfieldID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2034
  // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2035
  // passed in) so the field and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2036
  // table.  If they're not there, the field doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2037
  TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2038
  TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2039
  if (fieldname == NULL || signame == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2040
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2041
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2042
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2043
  // Make sure class is initialized before handing id's out to fields
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2044
  k->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2045
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2046
  fieldDescriptor fd;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2047
  if (!k->is_instance_klass() ||
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2048
      !InstanceKlass::cast(k)->find_field(fieldname, signame, false, &fd)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2049
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2050
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2052
  // A jfieldID for a non-static field is simply the offset of the field within the instanceOop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2053
  // It may also have hash bits for k, if VerifyJNIFields is turned on.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2054
  ret = jfieldIDWorkaround::to_instance_jfieldID(k, fd.offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2055
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2056
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2057
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2058
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2059
JNI_ENTRY(jobject, jni_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2060
  JNIWrapper("GetObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2061
  HOTSPOT_JNI_GETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2062
  oop o = JNIHandles::resolve_non_null(obj);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2063
  Klass* k = o->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2064
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2065
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2066
  // jni_GetField_probe() assumes that is okay to create handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2067
  if (JvmtiExport::should_post_field_access()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2068
    o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2069
  }
47998
fb0275c320a0 8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents: 47796
diff changeset
  2070
  oop loaded_obj = HeapAccess<ON_UNKNOWN_OOP_REF>::oop_load_at(o, offset);
fb0275c320a0 8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents: 47796
diff changeset
  2071
  jobject ret = JNIHandles::make_local(env, loaded_obj);
fb0275c320a0 8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents: 47796
diff changeset
  2072
  HOTSPOT_JNI_GETOBJECTFIELD_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2073
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2074
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2075
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2076
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2077
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2078
#define DEFINE_GETFIELD(Return,Fieldname,Result \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2079
  , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2080
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2081
  DT_RETURN_MARK_DECL_FOR(Result, Get##Result##Field, Return \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2082
  , ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2083
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2084
JNI_QUICK_ENTRY(Return, jni_Get##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2085
  JNIWrapper("Get" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2086
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2087
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2088
  Return ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2089
  DT_RETURN_MARK_FOR(Result, Get##Result##Field, Return, (const Return&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2090
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2091
  oop o = JNIHandles::resolve_non_null(obj); \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2092
  Klass* k = o->klass(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2093
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2094
  /* Keep JVMTI addition small and only check enabled flag here.       */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2095
  /* jni_GetField_probe_nh() assumes that is not okay to create handles */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2096
  /* and creates a ResetNoHandleMark.                                   */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2097
  if (JvmtiExport::should_post_field_access()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2098
    o = JvmtiExport::jni_GetField_probe_nh(thread, obj, o, k, fieldID, false); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2099
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2100
  ret = o->Fieldname##_field(offset); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2101
  return ret; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2102
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2103
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2104
DEFINE_GETFIELD(jboolean, bool,   Boolean
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2105
                , HOTSPOT_JNI_GETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2106
                HOTSPOT_JNI_GETBOOLEANFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2107
DEFINE_GETFIELD(jbyte,    byte,   Byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2108
                , HOTSPOT_JNI_GETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2109
                HOTSPOT_JNI_GETBYTEFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2110
DEFINE_GETFIELD(jchar,    char,   Char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2111
                , HOTSPOT_JNI_GETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2112
                HOTSPOT_JNI_GETCHARFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2113
DEFINE_GETFIELD(jshort,   short,  Short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2114
                , HOTSPOT_JNI_GETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2115
                HOTSPOT_JNI_GETSHORTFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2116
DEFINE_GETFIELD(jint,     int,    Int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2117
                , HOTSPOT_JNI_GETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2118
                HOTSPOT_JNI_GETINTFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2119
DEFINE_GETFIELD(jlong,    long,   Long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2120
                , HOTSPOT_JNI_GETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2121
                HOTSPOT_JNI_GETLONGFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2122
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2123
DEFINE_GETFIELD(jfloat,   float,  Float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2124
                , HOTSPOT_JNI_GETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2125
                HOTSPOT_JNI_GETFLOATFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2126
DEFINE_GETFIELD(jdouble,  double, Double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2127
                , HOTSPOT_JNI_GETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2128
                HOTSPOT_JNI_GETDOUBLEFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2129
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2130
address jni_GetBooleanField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2131
  return (address)jni_GetBooleanField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
address jni_GetByteField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2134
  return (address)jni_GetByteField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2135
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
address jni_GetCharField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
  return (address)jni_GetCharField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
address jni_GetShortField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2140
  return (address)jni_GetShortField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2141
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2142
address jni_GetIntField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
  return (address)jni_GetIntField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2144
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
address jni_GetLongField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
  return (address)jni_GetLongField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2148
address jni_GetFloatField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
  return (address)jni_GetFloatField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
address jni_GetDoubleField_addr() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2152
  return (address)jni_GetDoubleField;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2153
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2154
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2155
JNI_QUICK_ENTRY(void, jni_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2156
  JNIWrapper("SetObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2157
  HOTSPOT_JNI_SETOBJECTFIELD_ENTRY(env, obj, (uintptr_t) fieldID, value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2158
  oop o = JNIHandles::resolve_non_null(obj);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2159
  Klass* k = o->klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2160
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2161
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2162
  // jni_SetField_probe_nh() assumes that is not okay to create handles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2163
  // and creates a ResetNoHandleMark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2164
  if (JvmtiExport::should_post_field_modification()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2165
    jvalue field_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2166
    field_value.l = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2167
    o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, 'L', (jvalue *)&field_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2168
  }
47998
fb0275c320a0 8189871: Refactor GC barriers to use declarative semantics
eosterlund
parents: 47796
diff changeset
  2169
  HeapAccess<ON_UNKNOWN_OOP_REF>::oop_store_at(o, offset, JNIHandles::resolve(value));
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2170
  HOTSPOT_JNI_SETOBJECTFIELD_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2171
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2172
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2173
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2174
#define DEFINE_SETFIELD(Argument,Fieldname,Result,SigType,unionType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2175
                        , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2176
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2177
JNI_QUICK_ENTRY(void, jni_Set##Result##Field(JNIEnv *env, jobject obj, jfieldID fieldID, Argument value)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2178
  JNIWrapper("Set" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2179
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2180
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2181
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2182
  oop o = JNIHandles::resolve_non_null(obj); \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2183
  Klass* k = o->klass(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2184
  int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2185
  /* Keep JVMTI addition small and only check enabled flag here.       */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2186
  /* jni_SetField_probe_nh() assumes that is not okay to create handles */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2187
  /* and creates a ResetNoHandleMark.                                   */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2188
  if (JvmtiExport::should_post_field_modification()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2189
    jvalue field_value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2190
    field_value.unionType = value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2191
    o = JvmtiExport::jni_SetField_probe_nh(thread, obj, o, k, fieldID, false, SigType, (jvalue *)&field_value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2192
  } \
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 37248
diff changeset
  2193
  if (SigType == 'Z') { value = ((jboolean)value) & 1; } \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2194
  o->Fieldname##_field_put(offset, value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2195
  ReturnProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2196
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2197
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2198
DEFINE_SETFIELD(jboolean, bool,   Boolean, 'Z', z
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2199
                , HOTSPOT_JNI_SETBOOLEANFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2200
                HOTSPOT_JNI_SETBOOLEANFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2201
DEFINE_SETFIELD(jbyte,    byte,   Byte,    'B', b
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2202
                , HOTSPOT_JNI_SETBYTEFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2203
                HOTSPOT_JNI_SETBYTEFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2204
DEFINE_SETFIELD(jchar,    char,   Char,    'C', c
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2205
                , HOTSPOT_JNI_SETCHARFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2206
                HOTSPOT_JNI_SETCHARFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2207
DEFINE_SETFIELD(jshort,   short,  Short,   'S', s
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2208
                , HOTSPOT_JNI_SETSHORTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2209
                HOTSPOT_JNI_SETSHORTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2210
DEFINE_SETFIELD(jint,     int,    Int,     'I', i
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2211
                , HOTSPOT_JNI_SETINTFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2212
                HOTSPOT_JNI_SETINTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2213
DEFINE_SETFIELD(jlong,    long,   Long,    'J', j
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2214
                , HOTSPOT_JNI_SETLONGFIELD_ENTRY(env, obj, (uintptr_t)fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2215
                HOTSPOT_JNI_SETLONGFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2216
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2217
DEFINE_SETFIELD(jfloat,   float,  Float,   'F', f
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2218
                , HOTSPOT_JNI_SETFLOATFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2219
                HOTSPOT_JNI_SETFLOATFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2220
DEFINE_SETFIELD(jdouble,  double, Double,  'D', d
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2221
                , HOTSPOT_JNI_SETDOUBLEFIELD_ENTRY(env, obj, (uintptr_t)fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2222
                HOTSPOT_JNI_SETDOUBLEFIELD_RETURN())
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2223
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2224
DT_RETURN_MARK_DECL(ToReflectedField, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2225
                    , HOTSPOT_JNI_TOREFLECTEDFIELD_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2226
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
JNI_ENTRY(jobject, jni_ToReflectedField(JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
  JNIWrapper("ToReflectedField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2229
  HOTSPOT_JNI_TOREFLECTEDFIELD_ENTRY(env, cls, (uintptr_t) fieldID, isStatic);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
  DT_RETURN_MARK(ToReflectedField, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
  fieldDescriptor fd;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2234
  bool found = false;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2235
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2237
  assert(jfieldIDWorkaround::is_static_jfieldID(fieldID) == (isStatic != 0), "invalid fieldID");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2239
  if (isStatic) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2240
    // Static field. The fieldID a JNIid specifying the field holder and the offset within the Klass*.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2241
    JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2242
    assert(id->is_static_field_id(), "invalid static field id");
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2243
    found = id->find_local_field(&fd);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2245
    // Non-static field. The fieldID is really the offset of the field within the instanceOop.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2246
    int offset = jfieldIDWorkaround::from_instance_jfieldID(k, fieldID);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2247
    found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, &fd);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
  assert(found, "bad fieldID passed into jni_ToReflectedField");
24456
8c7933fa5a1f 8025580: Temporary flags: UseNewReflection and ReflectionWrapResolutionErrors
coleenp
parents: 24424
diff changeset
  2250
  oop reflected = Reflection::new_field(&fd, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2251
  ret = JNIHandles::make_local(env, reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2253
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2256
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2257
// Accessing Static Fields
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2258
//
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2259
DT_RETURN_MARK_DECL(GetStaticFieldID, jfieldID
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2260
                    , HOTSPOT_JNI_GETSTATICFIELDID_RETURN((uintptr_t)_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
JNI_ENTRY(jfieldID, jni_GetStaticFieldID(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
          const char *name, const char *sig))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
  JNIWrapper("GetStaticFieldID");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2265
  HOTSPOT_JNI_GETSTATICFIELDID_ENTRY(env, clazz, (char *) name, (char *) sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
  jfieldID ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2267
  DT_RETURN_MARK(GetStaticFieldID, jfieldID, (const jfieldID&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
  // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2270
  // passed in) so the field and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
  // table.  If they're not there, the field doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2272
  TempNewSymbol fieldname = SymbolTable::probe(name, (int)strlen(name));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2273
  TempNewSymbol signame = SymbolTable::probe(sig, (int)strlen(sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2274
  if (fieldname == NULL || signame == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2276
  }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2277
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
  // Make sure class is initialized before handing id's out to static fields
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2279
  k->initialize(CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2281
  fieldDescriptor fd;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2282
  if (!k->is_instance_klass() ||
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2283
      !InstanceKlass::cast(k)->find_field(fieldname, signame, true, &fd)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
    THROW_MSG_0(vmSymbols::java_lang_NoSuchFieldError(), (char*) name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2287
  // A jfieldID for a static field is a JNIid specifying the field holder and the offset within the Klass*
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13977
diff changeset
  2288
  JNIid* id = fd.field_holder()->jni_id_for(fd.offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
  debug_only(id->set_is_static_field_id();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2290
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2291
  debug_only(id->verify(fd.field_holder()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
  ret = jfieldIDWorkaround::to_static_jfieldID(id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2294
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2298
JNI_ENTRY(jobject, jni_GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2299
  JNIWrapper("GetStaticObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2300
  HOTSPOT_JNI_GETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID);
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2301
#if INCLUDE_JNI_CHECK
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2302
  DEBUG_ONLY(Klass* param_k = jniCheck::validate_class(thread, clazz);)
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2303
#endif // INCLUDE_JNI_CHECK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2304
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2305
  assert(id->is_static_field_id(), "invalid static field id");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2306
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2307
  // jni_GetField_probe() assumes that is okay to create handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2308
  if (JvmtiExport::should_post_field_access()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2309
    JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2310
  }
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2311
  jobject ret = JNIHandles::make_local(id->holder()->java_mirror()->obj_field(id->offset()));
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2312
  HOTSPOT_JNI_GETSTATICOBJECTFIELD_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2313
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2315
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2316
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2317
#define DEFINE_GETSTATICFIELD(Return,Fieldname,Result \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2318
                              , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2319
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2320
  DT_RETURN_MARK_DECL_FOR(Result, GetStatic##Result##Field, Return \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2321
                          , ReturnProbe);                                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2322
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2323
JNI_ENTRY(Return, jni_GetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2324
  JNIWrapper("GetStatic" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2325
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2326
  Return ret = 0;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2327
  DT_RETURN_MARK_FOR(Result, GetStatic##Result##Field, Return, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2328
                     (const Return&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2329
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2330
  assert(id->is_static_field_id(), "invalid static field id"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2331
  /* Keep JVMTI addition small and only check enabled flag here. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2332
  /* jni_GetField_probe() assumes that is okay to create handles. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2333
  if (JvmtiExport::should_post_field_access()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2334
    JvmtiExport::jni_GetField_probe(thread, NULL, NULL, id->holder(), fieldID, true); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2335
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2336
  ret = id->holder()->java_mirror()-> Fieldname##_field (id->offset()); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2337
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2338
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2339
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2340
DEFINE_GETSTATICFIELD(jboolean, bool,   Boolean
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2341
                      , HOTSPOT_JNI_GETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t) fieldID), HOTSPOT_JNI_GETSTATICBOOLEANFIELD_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2342
DEFINE_GETSTATICFIELD(jbyte,    byte,   Byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2343
                      , HOTSPOT_JNI_GETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),    HOTSPOT_JNI_GETSTATICBYTEFIELD_RETURN(_ret_ref)   )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2344
DEFINE_GETSTATICFIELD(jchar,    char,   Char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2345
                      , HOTSPOT_JNI_GETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),    HOTSPOT_JNI_GETSTATICCHARFIELD_RETURN(_ret_ref)   )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2346
DEFINE_GETSTATICFIELD(jshort,   short,  Short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2347
                      , HOTSPOT_JNI_GETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),   HOTSPOT_JNI_GETSTATICSHORTFIELD_RETURN(_ret_ref)  )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2348
DEFINE_GETSTATICFIELD(jint,     int,    Int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2349
                      , HOTSPOT_JNI_GETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),     HOTSPOT_JNI_GETSTATICINTFIELD_RETURN(_ret_ref)    )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2350
DEFINE_GETSTATICFIELD(jlong,    long,   Long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2351
                      , HOTSPOT_JNI_GETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),    HOTSPOT_JNI_GETSTATICLONGFIELD_RETURN(_ret_ref)   )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2352
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2353
DEFINE_GETSTATICFIELD(jfloat,   float,  Float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2354
                      , HOTSPOT_JNI_GETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),   HOTSPOT_JNI_GETSTATICFLOATFIELD_RETURN()          )
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2355
DEFINE_GETSTATICFIELD(jdouble,  double, Double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2356
                      , HOTSPOT_JNI_GETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),  HOTSPOT_JNI_GETSTATICDOUBLEFIELD_RETURN()         )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2357
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2358
JNI_ENTRY(void, jni_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
  JNIWrapper("SetStaticObjectField");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2360
 HOTSPOT_JNI_SETSTATICOBJECTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2361
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
  assert(id->is_static_field_id(), "invalid static field id");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
  // Keep JVMTI addition small and only check enabled flag here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
  // jni_SetField_probe() assumes that is okay to create handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
  if (JvmtiExport::should_post_field_modification()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
    jvalue field_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
    field_value.l = value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
    JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, 'L', (jvalue *)&field_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2369
  }
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8076
diff changeset
  2370
  id->holder()->java_mirror()->obj_field_put(id->offset(), JNIHandles::resolve(value));
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2371
  HOTSPOT_JNI_SETSTATICOBJECTFIELD_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2372
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2374
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2375
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2376
#define DEFINE_SETSTATICFIELD(Argument,Fieldname,Result,SigType,unionType \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2377
                              , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2378
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2379
JNI_ENTRY(void, jni_SetStatic##Result##Field(JNIEnv *env, jclass clazz, jfieldID fieldID, Argument value)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2380
  JNIWrapper("SetStatic" XSTR(Result) "Field"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2381
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2382
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2383
  JNIid* id = jfieldIDWorkaround::from_static_jfieldID(fieldID); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2384
  assert(id->is_static_field_id(), "invalid static field id"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2385
  /* Keep JVMTI addition small and only check enabled flag here. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2386
  /* jni_SetField_probe() assumes that is okay to create handles. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2387
  if (JvmtiExport::should_post_field_modification()) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2388
    jvalue field_value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2389
    field_value.unionType = value; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2390
    JvmtiExport::jni_SetField_probe(thread, NULL, NULL, id->holder(), fieldID, true, SigType, (jvalue *)&field_value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2391
  } \
37480
291ee208fb72 8132051: Better byte behavior
coleenp
parents: 37248
diff changeset
  2392
  if (SigType == 'Z') { value = ((jboolean)value) & 1; } \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2393
  id->holder()->java_mirror()-> Fieldname##_field_put (id->offset(), value); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2394
  ReturnProbe;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2395
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2396
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2397
DEFINE_SETSTATICFIELD(jboolean, bool,   Boolean, 'Z', z
22190
d306a75a70d3 8029726: On OS X some dtrace probe names are mismatched with Solaris
sla
parents: 21112
diff changeset
  2398
                      , HOTSPOT_JNI_SETSTATICBOOLEANFIELD_ENTRY(env, clazz, (uintptr_t)fieldID, value),
23997
73485c7e8122 8039947: Dtrace return probe name for jni_SetStaticBooleanField named incorrectly
dsimms
parents: 23859
diff changeset
  2399
                      HOTSPOT_JNI_SETSTATICBOOLEANFIELD_RETURN())
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2400
DEFINE_SETSTATICFIELD(jbyte,    byte,   Byte,    'B', b
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2401
                      , HOTSPOT_JNI_SETSTATICBYTEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2402
                      HOTSPOT_JNI_SETSTATICBYTEFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2403
DEFINE_SETSTATICFIELD(jchar,    char,   Char,    'C', c
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2404
                      , HOTSPOT_JNI_SETSTATICCHARFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2405
                      HOTSPOT_JNI_SETSTATICCHARFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2406
DEFINE_SETSTATICFIELD(jshort,   short,  Short,   'S', s
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2407
                      , HOTSPOT_JNI_SETSTATICSHORTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2408
                      HOTSPOT_JNI_SETSTATICSHORTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2409
DEFINE_SETSTATICFIELD(jint,     int,    Int,     'I', i
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2410
                      , HOTSPOT_JNI_SETSTATICINTFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2411
                      HOTSPOT_JNI_SETSTATICINTFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2412
DEFINE_SETSTATICFIELD(jlong,    long,   Long,    'J', j
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2413
                      , HOTSPOT_JNI_SETSTATICLONGFIELD_ENTRY(env, clazz, (uintptr_t) fieldID, value),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2414
                      HOTSPOT_JNI_SETSTATICLONGFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2415
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2416
DEFINE_SETSTATICFIELD(jfloat,   float,  Float,   'F', f
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2417
                      , HOTSPOT_JNI_SETSTATICFLOATFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2418
                      HOTSPOT_JNI_SETSTATICFLOATFIELD_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2419
DEFINE_SETSTATICFIELD(jdouble,  double, Double,  'D', d
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2420
                      , HOTSPOT_JNI_SETSTATICDOUBLEFIELD_ENTRY(env, clazz, (uintptr_t) fieldID),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2421
                      HOTSPOT_JNI_SETSTATICDOUBLEFIELD_RETURN())
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2423
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2424
// String Operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2425
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2426
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2427
// Unicode Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2428
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2429
DT_RETURN_MARK_DECL(NewString, jstring
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2430
                    , HOTSPOT_JNI_NEWSTRING_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2431
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2432
JNI_ENTRY(jstring, jni_NewString(JNIEnv *env, const jchar *unicodeChars, jsize len))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2433
  JNIWrapper("NewString");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2434
 HOTSPOT_JNI_NEWSTRING_ENTRY(env, (uint16_t *) unicodeChars, len);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2435
  jstring ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
  DT_RETURN_MARK(NewString, jstring, (const jstring&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2437
  oop string=java_lang_String::create_oop_from_unicode((jchar*) unicodeChars, len, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2438
  ret = (jstring) JNIHandles::make_local(env, string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2439
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2440
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2441
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2442
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2443
JNI_QUICK_ENTRY(jsize, jni_GetStringLength(JNIEnv *env, jstring string))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2444
  JNIWrapper("GetStringLength");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2445
  HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(env, string);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2446
  jsize ret = 0;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2447
  oop s = JNIHandles::resolve_non_null(string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2448
  if (java_lang_String::value(s) != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2449
    ret = java_lang_String::length(s);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2450
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2451
 HOTSPOT_JNI_GETSTRINGLENGTH_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2453
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2454
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2456
JNI_QUICK_ENTRY(const jchar*, jni_GetStringChars(
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
  JNIEnv *env, jstring string, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2458
  JNIWrapper("GetStringChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2459
 HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2460
  jchar* buf = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2461
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2462
  typeArrayOop s_value = java_lang_String::value(s);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2463
  if (s_value != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2464
    int s_len = java_lang_String::length(s);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2465
    bool is_latin1 = java_lang_String::is_latin1(s);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2466
    buf = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal);  // add one for zero termination
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2467
    /* JNI Specification states return NULL on OOM */
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2468
    if (buf != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2469
      if (s_len > 0) {
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2470
        if (!is_latin1) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2471
          memcpy(buf, s_value->char_at_addr(0), sizeof(jchar)*s_len);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2472
        } else {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2473
          for (int i = 0; i < s_len; i++) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2474
            buf[i] = ((jchar) s_value->byte_at(i)) & 0xff;
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2475
          }
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  2476
        }
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2477
      }
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2478
      buf[s_len] = 0;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2479
      //%note jni_5
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2480
      if (isCopy != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2481
        *isCopy = JNI_TRUE;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2482
      }
19545
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2483
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2484
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2485
  HOTSPOT_JNI_GETSTRINGCHARS_RETURN(buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2486
  return buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2487
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2488
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2489
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
JNI_QUICK_ENTRY(void, jni_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2491
  JNIWrapper("ReleaseStringChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2492
  HOTSPOT_JNI_RELEASESTRINGCHARS_ENTRY(env, str, (uint16_t *) chars);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2493
  //%note jni_6
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
  if (chars != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
    // Since String objects are supposed to be immutable, don't copy any
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2496
    // new data back.  A bad user will have to go after the char array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
    FreeHeap((void*) chars);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2498
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2499
  HOTSPOT_JNI_RELEASESTRINGCHARS_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2501
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2502
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2503
// UTF Interface
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2504
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2505
DT_RETURN_MARK_DECL(NewStringUTF, jstring
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2506
                    , HOTSPOT_JNI_NEWSTRINGUTF_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2507
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
JNI_ENTRY(jstring, jni_NewStringUTF(JNIEnv *env, const char *bytes))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2509
  JNIWrapper("NewStringUTF");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2510
  HOTSPOT_JNI_NEWSTRINGUTF_ENTRY(env, (char *) bytes);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
  jstring ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
  DT_RETURN_MARK(NewStringUTF, jstring, (const jstring&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
  oop result = java_lang_String::create_oop_from_str((char*) bytes, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
  ret = (jstring) JNIHandles::make_local(env, result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
JNI_ENTRY(jsize, jni_GetStringUTFLength(JNIEnv *env, jstring string))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
  JNIWrapper("GetStringUTFLength");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2522
 HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(env, string);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2523
  jsize ret = 0;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2524
  oop java_string = JNIHandles::resolve_non_null(string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2525
  if (java_lang_String::value(java_string) != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2526
    ret = java_lang_String::utf8_length(java_string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2527
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2528
  HOTSPOT_JNI_GETSTRINGUTFLENGTH_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2530
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2531
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
JNI_ENTRY(const char*, jni_GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
  JNIWrapper("GetStringUTFChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2535
 HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(env, string, (uintptr_t *) isCopy);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2536
  char* result = NULL;
7414
940d84ca7fca 6539281: -Xcheck:jni should validate char* argument to ReleaseStringUTFChars
sla
parents: 7405
diff changeset
  2537
  oop java_string = JNIHandles::resolve_non_null(string);
20387
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2538
  if (java_lang_String::value(java_string) != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2539
    size_t length = java_lang_String::utf8_length(java_string);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2540
    /* JNI Specification states return NULL on OOM */
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2541
    result = AllocateHeap(length + 1, mtInternal, 0, AllocFailStrategy::RETURN_NULL);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2542
    if (result != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2543
      java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2544
      if (isCopy != NULL) {
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2545
        *isCopy = JNI_TRUE;
df9f9f220120 8025922: JNI access to Strings need to check if the value field is non-null
sla
parents: 20084
diff changeset
  2546
      }
19545
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2547
    }
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2548
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2549
 HOTSPOT_JNI_GETSTRINGUTFCHARS_RETURN(result);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
JNI_LEAF(void, jni_ReleaseStringUTFChars(JNIEnv *env, jstring str, const char *chars))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
  JNIWrapper("ReleaseStringUTFChars");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2556
 HOTSPOT_JNI_RELEASESTRINGUTFCHARS_ENTRY(env, str, (char *) chars);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
  if (chars != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
    FreeHeap((char*) chars);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2560
HOTSPOT_JNI_RELEASESTRINGUTFCHARS_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2561
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
JNI_QUICK_ENTRY(jsize, jni_GetArrayLength(JNIEnv *env, jarray array))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
  JNIWrapper("GetArrayLength");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2566
 HOTSPOT_JNI_GETARRAYLENGTH_ENTRY(env, array);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
  arrayOop a = arrayOop(JNIHandles::resolve_non_null(array));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
  assert(a->is_array(), "must be array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
  jsize ret = a->length();
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2570
 HOTSPOT_JNI_GETARRAYLENGTH_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2575
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
// Object Array Operations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2579
DT_RETURN_MARK_DECL(NewObjectArray, jobjectArray
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2580
                    , HOTSPOT_JNI_NEWOBJECTARRAY_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2581
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
  JNIWrapper("NewObjectArray");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2584
 HOTSPOT_JNI_NEWOBJECTARRAY_ENTRY(env, length, elementClass, initialElement);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
  jobjectArray ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
  DT_RETURN_MARK(NewObjectArray, jobjectArray, (const jobjectArray&)ret);
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2587
  Klass* ek = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass));
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2588
  Klass* ak = ek->array_klass(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2589
  ObjArrayKlass::cast(ak)->initialize(CHECK_NULL);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2590
  objArrayOop result = ObjArrayKlass::cast(ak)->allocate(length, CHECK_NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
  oop initial_value = JNIHandles::resolve(initialElement);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
  if (initial_value != NULL) {  // array already initialized with NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
    for (int index = 0; index < length; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2594
      result->obj_at_put(index, initial_value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2597
  ret = (jobjectArray) JNIHandles::make_local(env, result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2601
DT_RETURN_MARK_DECL(GetObjectArrayElement, jobject
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2602
                    , HOTSPOT_JNI_GETOBJECTARRAYELEMENT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2604
JNI_ENTRY(jobject, jni_GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
  JNIWrapper("GetObjectArrayElement");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2606
 HOTSPOT_JNI_GETOBJECTARRAYELEMENT_ENTRY(env, array, index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2607
  jobject ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2608
  DT_RETURN_MARK(GetObjectArrayElement, jobject, (const jobject&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2609
  objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2610
  if (a->is_within_bounds(index)) {
4089
14bd2cd13a2c 6893483: DTrace probe return values for a couple JNI methods are wrong
kamg
parents: 3820
diff changeset
  2611
    ret = JNIHandles::make_local(env, a->obj_at(index));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2612
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2613
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2614
    char buf[jintAsStringSize];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2615
    sprintf(buf, "%d", index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2616
    THROW_MSG_0(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2617
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2618
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2619
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2620
DT_VOID_RETURN_MARK_DECL(SetObjectArrayElement
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2621
                         , HOTSPOT_JNI_SETOBJECTARRAYELEMENT_RETURN());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2622
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2623
JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2624
  JNIWrapper("SetObjectArrayElement");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2625
 HOTSPOT_JNI_SETOBJECTARRAYELEMENT_ENTRY(env, array, index, value);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2626
  DT_VOID_RETURN_MARK(SetObjectArrayElement);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2627
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2628
  objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2629
  oop v = JNIHandles::resolve(value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2630
  if (a->is_within_bounds(index)) {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  2631
    if (v == NULL || v->is_a(ObjArrayKlass::cast(a->klass())->element_klass())) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2632
      a->obj_at_put(index, v);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2633
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2634
      THROW(vmSymbols::java_lang_ArrayStoreException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2635
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2636
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2637
    char buf[jintAsStringSize];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2638
    sprintf(buf, "%d", index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2639
    THROW_MSG(vmSymbols::java_lang_ArrayIndexOutOfBoundsException(), buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2640
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2641
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2642
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2643
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2644
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2645
#define DEFINE_NEWSCALARARRAY(Return,Allocator,Result \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2646
                              ,EntryProbe,ReturnProbe)  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2647
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2648
  DT_RETURN_MARK_DECL(New##Result##Array, Return \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2649
                      , ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2650
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2651
JNI_ENTRY(Return, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2652
          jni_New##Result##Array(JNIEnv *env, jsize len)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2653
  JNIWrapper("New" XSTR(Result) "Array"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2654
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2655
  Return ret = NULL;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2656
  DT_RETURN_MARK(New##Result##Array, Return, (const Return&)ret);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2657
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2658
  oop obj= oopFactory::Allocator(len, CHECK_0); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2659
  ret = (Return) JNIHandles::make_local(env, obj); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2660
  return ret;\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2661
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2662
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2663
DEFINE_NEWSCALARARRAY(jbooleanArray, new_boolArray,   Boolean,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2664
                      HOTSPOT_JNI_NEWBOOLEANARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2665
                      HOTSPOT_JNI_NEWBOOLEANARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2666
DEFINE_NEWSCALARARRAY(jbyteArray,    new_byteArray,   Byte,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2667
                      HOTSPOT_JNI_NEWBYTEARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2668
                      HOTSPOT_JNI_NEWBYTEARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2669
DEFINE_NEWSCALARARRAY(jshortArray,   new_shortArray,  Short,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2670
                      HOTSPOT_JNI_NEWSHORTARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2671
                      HOTSPOT_JNI_NEWSHORTARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2672
DEFINE_NEWSCALARARRAY(jcharArray,    new_charArray,   Char,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2673
                      HOTSPOT_JNI_NEWCHARARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2674
                      HOTSPOT_JNI_NEWCHARARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2675
DEFINE_NEWSCALARARRAY(jintArray,     new_intArray,    Int,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2676
                      HOTSPOT_JNI_NEWINTARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2677
                      HOTSPOT_JNI_NEWINTARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2678
DEFINE_NEWSCALARARRAY(jlongArray,    new_longArray,   Long,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2679
                      HOTSPOT_JNI_NEWLONGARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2680
                      HOTSPOT_JNI_NEWLONGARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2681
DEFINE_NEWSCALARARRAY(jfloatArray,   new_singleArray, Float,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2682
                      HOTSPOT_JNI_NEWFLOATARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2683
                      HOTSPOT_JNI_NEWFLOATARRAY_RETURN(_ret_ref))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2684
DEFINE_NEWSCALARARRAY(jdoubleArray,  new_doubleArray, Double,
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2685
                      HOTSPOT_JNI_NEWDOUBLEARRAY_ENTRY(env, len),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2686
                      HOTSPOT_JNI_NEWDOUBLEARRAY_RETURN(_ret_ref))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2687
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2688
// Return an address which will fault if the caller writes to it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2689
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2690
static char* get_bad_address() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2691
  static char* bad_address = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2692
  if (bad_address == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2693
    size_t size = os::vm_allocation_granularity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2694
    bad_address = os::reserve_memory(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2695
    if (bad_address != NULL) {
1664
fc9ed50498fb 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 823
diff changeset
  2696
      os::protect_memory(bad_address, size, os::MEM_PROT_READ,
fc9ed50498fb 6727377: VM stack guard pages on Windows should PAGE_READWRITE not PAGE_EXECUTE_READWRITE
coleenp
parents: 823
diff changeset
  2697
                         /*is_committed*/false);
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25633
diff changeset
  2698
      MemTracker::record_virtual_memory_type((void*)bad_address, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
  return bad_address;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2705
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2706
#define DEFINE_GETSCALARARRAYELEMENTS(ElementTag,ElementType,Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2707
                                      , EntryProbe, ReturnProbe) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2708
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2709
JNI_QUICK_ENTRY(ElementType*, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2710
          jni_Get##Result##ArrayElements(JNIEnv *env, ElementType##Array array, jboolean *isCopy)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2711
  JNIWrapper("Get" XSTR(Result) "ArrayElements"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2712
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2713
  /* allocate an chunk of memory in c land */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2714
  typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2715
  ElementType* result; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2716
  int len = a->length(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2717
  if (len == 0) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2718
    /* Empty array: legal but useless, can't return NULL. \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2719
     * Return a pointer to something useless. \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2720
     * Avoid asserts in typeArrayOop. */ \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2721
    result = (ElementType*)get_bad_address(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2722
  } else { \
19545
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2723
    /* JNI Specification states return NULL on OOM */                    \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2724
    result = NEW_C_HEAP_ARRAY_RETURN_NULL(ElementType, len, mtInternal); \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2725
    if (result != NULL) {                                                \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2726
      /* copy the array to the c chunk */                                \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2727
      memcpy(result, a->Tag##_at_addr(0), sizeof(ElementType)*len);      \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2728
      if (isCopy) {                                                      \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2729
        *isCopy = JNI_TRUE;                                              \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2730
      }                                                                  \
409c50cf1e5d 8022683: JNI GetStringUTFChars should return NULL on allocation failure not abort the VM
dsimms
parents: 18683
diff changeset
  2731
    }                                                                    \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2732
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2733
  ReturnProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2734
  return result; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2735
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2736
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2737
DEFINE_GETSCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2738
                              , HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2739
                              HOTSPOT_JNI_GETBOOLEANARRAYELEMENTS_RETURN((uintptr_t*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2740
DEFINE_GETSCALARARRAYELEMENTS(T_BYTE,    jbyte,    Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2741
                              , HOTSPOT_JNI_GETBYTEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2742
                              HOTSPOT_JNI_GETBYTEARRAYELEMENTS_RETURN((char*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2743
DEFINE_GETSCALARARRAYELEMENTS(T_SHORT,   jshort,   Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2744
                              , HOTSPOT_JNI_GETSHORTARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2745
                              HOTSPOT_JNI_GETSHORTARRAYELEMENTS_RETURN((uint16_t*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2746
DEFINE_GETSCALARARRAYELEMENTS(T_CHAR,    jchar,    Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2747
                              , HOTSPOT_JNI_GETCHARARRAYELEMENTS_ENTRY(env, (uint16_t*) array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2748
                              HOTSPOT_JNI_GETCHARARRAYELEMENTS_RETURN(result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2749
DEFINE_GETSCALARARRAYELEMENTS(T_INT,     jint,     Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2750
                              , HOTSPOT_JNI_GETINTARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2751
                              HOTSPOT_JNI_GETINTARRAYELEMENTS_RETURN((uint32_t*)result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2752
DEFINE_GETSCALARARRAYELEMENTS(T_LONG,    jlong,    Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2753
                              , HOTSPOT_JNI_GETLONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2754
                              HOTSPOT_JNI_GETLONGARRAYELEMENTS_RETURN(((uintptr_t*)result)))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2755
// Float and double probes don't return value because dtrace doesn't currently support it
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2756
DEFINE_GETSCALARARRAYELEMENTS(T_FLOAT,   jfloat,   Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2757
                              , HOTSPOT_JNI_GETFLOATARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2758
                              HOTSPOT_JNI_GETFLOATARRAYELEMENTS_RETURN(result))
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2759
DEFINE_GETSCALARARRAYELEMENTS(T_DOUBLE,  jdouble,  Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2760
                              , HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) isCopy),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2761
                              HOTSPOT_JNI_GETDOUBLEARRAYELEMENTS_RETURN(result))
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2762
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2763
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2764
#define DEFINE_RELEASESCALARARRAYELEMENTS(ElementTag,ElementType,Result,Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2765
                                          , EntryProbe, ReturnProbe);\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2766
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2767
JNI_QUICK_ENTRY(void, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2768
          jni_Release##Result##ArrayElements(JNIEnv *env, ElementType##Array array, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2769
                                             ElementType *buf, jint mode)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2770
  JNIWrapper("Release" XSTR(Result) "ArrayElements"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2771
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2772
  typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(array)); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2773
  int len = a->length(); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2774
  if (len != 0) {   /* Empty array:  nothing to free or copy. */  \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2775
    if ((mode == 0) || (mode == JNI_COMMIT)) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2776
      memcpy(a->Tag##_at_addr(0), buf, sizeof(ElementType)*len); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2777
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2778
    if ((mode == 0) || (mode == JNI_ABORT)) { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2779
      FreeHeap(buf); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2780
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2781
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2782
  ReturnProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2783
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2784
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2785
DEFINE_RELEASESCALARARRAYELEMENTS(T_BOOLEAN, jboolean, Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2786
                                  , HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2787
                                  HOTSPOT_JNI_RELEASEBOOLEANARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2788
DEFINE_RELEASESCALARARRAYELEMENTS(T_BYTE,    jbyte,    Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2789
                                  , HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_ENTRY(env, array, (char *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2790
                                  HOTSPOT_JNI_RELEASEBYTEARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2791
DEFINE_RELEASESCALARARRAYELEMENTS(T_SHORT,   jshort,   Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2792
                                  ,  HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2793
                                  HOTSPOT_JNI_RELEASESHORTARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2794
DEFINE_RELEASESCALARARRAYELEMENTS(T_CHAR,    jchar,    Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2795
                                  ,  HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_ENTRY(env, array, (uint16_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2796
                                  HOTSPOT_JNI_RELEASECHARARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2797
DEFINE_RELEASESCALARARRAYELEMENTS(T_INT,     jint,     Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2798
                                  , HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_ENTRY(env, array, (uint32_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2799
                                  HOTSPOT_JNI_RELEASEINTARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2800
DEFINE_RELEASESCALARARRAYELEMENTS(T_LONG,    jlong,    Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2801
                                  , HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_ENTRY(env, array, (uintptr_t *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2802
                                  HOTSPOT_JNI_RELEASELONGARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2803
DEFINE_RELEASESCALARARRAYELEMENTS(T_FLOAT,   jfloat,   Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2804
                                  , HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_ENTRY(env, array, (float *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2805
                                  HOTSPOT_JNI_RELEASEFLOATARRAYELEMENTS_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2806
DEFINE_RELEASESCALARARRAYELEMENTS(T_DOUBLE,  jdouble,  Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2807
                                  , HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_ENTRY(env, array, (double *) buf, mode),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2808
                                  HOTSPOT_JNI_RELEASEDOUBLEARRAYELEMENTS_RETURN())
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2809
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2810
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2811
#define DEFINE_GETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2812
                                    , EntryProbe, ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2813
  DT_VOID_RETURN_MARK_DECL(Get##Result##ArrayRegion \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2814
                           , ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2815
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2816
JNI_ENTRY(void, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2817
jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2818
             jsize len, ElementType *buf)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2819
  JNIWrapper("Get" XSTR(Result) "ArrayRegion"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2820
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2821
  DT_VOID_RETURN_MARK(Get##Result##ArrayRegion); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2822
  typeArrayOop src = typeArrayOop(JNIHandles::resolve_non_null(array)); \
48558
b2b67c8fc91a 8181664: Improve JVM UTF String handling
rprotacio
parents: 48105
diff changeset
  2823
  if (start < 0 || len < 0 || (start > src->length() - len)) { \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2824
    THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2825
  } else { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2826
    if (len > 0) { \
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  2827
      int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2828
      memcpy((u_char*) buf, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2829
             (u_char*) src->Tag##_at_addr(start), \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2830
             len << sc);                          \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2831
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2832
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2833
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2834
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2835
DEFINE_GETSCALARARRAYREGION(T_BOOLEAN, jboolean,Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2836
                            , HOTSPOT_JNI_GETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2837
                            HOTSPOT_JNI_GETBOOLEANARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2838
DEFINE_GETSCALARARRAYREGION(T_BYTE,    jbyte,   Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2839
                            ,  HOTSPOT_JNI_GETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2840
                            HOTSPOT_JNI_GETBYTEARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2841
DEFINE_GETSCALARARRAYREGION(T_SHORT,   jshort,  Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2842
                            , HOTSPOT_JNI_GETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2843
                            HOTSPOT_JNI_GETSHORTARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2844
DEFINE_GETSCALARARRAYREGION(T_CHAR,    jchar,   Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2845
                            ,  HOTSPOT_JNI_GETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t*) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2846
                            HOTSPOT_JNI_GETCHARARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2847
DEFINE_GETSCALARARRAYREGION(T_INT,     jint,    Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2848
                            , HOTSPOT_JNI_GETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t*) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2849
                            HOTSPOT_JNI_GETINTARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2850
DEFINE_GETSCALARARRAYREGION(T_LONG,    jlong,   Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2851
                            ,  HOTSPOT_JNI_GETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2852
                            HOTSPOT_JNI_GETLONGARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2853
DEFINE_GETSCALARARRAYREGION(T_FLOAT,   jfloat,  Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2854
                            , HOTSPOT_JNI_GETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2855
                            HOTSPOT_JNI_GETFLOATARRAYREGION_RETURN());
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2856
DEFINE_GETSCALARARRAYREGION(T_DOUBLE,  jdouble, Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2857
                            , HOTSPOT_JNI_GETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2858
                            HOTSPOT_JNI_GETDOUBLEARRAYREGION_RETURN());
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  2859
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2860
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2861
#define DEFINE_SETSCALARARRAYREGION(ElementTag,ElementType,Result, Tag \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2862
                                    , EntryProbe, ReturnProbe); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2863
  DT_VOID_RETURN_MARK_DECL(Set##Result##ArrayRegion \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2864
                           ,ReturnProbe);           \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2865
\
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2866
JNI_ENTRY(void, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2867
jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2868
             jsize len, const ElementType *buf)) \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2869
  JNIWrapper("Set" XSTR(Result) "ArrayRegion"); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2870
  EntryProbe; \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2871
  DT_VOID_RETURN_MARK(Set##Result##ArrayRegion); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2872
  typeArrayOop dst = typeArrayOop(JNIHandles::resolve_non_null(array)); \
48558
b2b67c8fc91a 8181664: Improve JVM UTF String handling
rprotacio
parents: 48105
diff changeset
  2873
  if (start < 0 || len < 0 || (start > dst->length() - len)) { \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2874
    THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2875
  } else { \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2876
    if (len > 0) { \
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  2877
      int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2878
      memcpy((u_char*) dst->Tag##_at_addr(start), \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2879
             (u_char*) buf, \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2880
             len << sc);    \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2881
    } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2882
  } \
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2883
JNI_END
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2884
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2885
DEFINE_SETSCALARARRAYREGION(T_BOOLEAN, jboolean, Boolean, bool
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2886
                            , HOTSPOT_JNI_SETBOOLEANARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *)buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2887
                            HOTSPOT_JNI_SETBOOLEANARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2888
DEFINE_SETSCALARARRAYREGION(T_BYTE,    jbyte,    Byte,    byte
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2889
                            , HOTSPOT_JNI_SETBYTEARRAYREGION_ENTRY(env, array, start, len, (char *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2890
                            HOTSPOT_JNI_SETBYTEARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2891
DEFINE_SETSCALARARRAYREGION(T_SHORT,   jshort,   Short,   short
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2892
                            , HOTSPOT_JNI_SETSHORTARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2893
                            HOTSPOT_JNI_SETSHORTARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2894
DEFINE_SETSCALARARRAYREGION(T_CHAR,    jchar,    Char,    char
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2895
                            , HOTSPOT_JNI_SETCHARARRAYREGION_ENTRY(env, array, start, len, (uint16_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2896
                            HOTSPOT_JNI_SETCHARARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2897
DEFINE_SETSCALARARRAYREGION(T_INT,     jint,     Int,     int
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2898
                            , HOTSPOT_JNI_SETINTARRAYREGION_ENTRY(env, array, start, len, (uint32_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2899
                            HOTSPOT_JNI_SETINTARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2900
DEFINE_SETSCALARARRAYREGION(T_LONG,    jlong,    Long,    long
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2901
                            , HOTSPOT_JNI_SETLONGARRAYREGION_ENTRY(env, array, start, len, (uintptr_t *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2902
                            HOTSPOT_JNI_SETLONGARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2903
DEFINE_SETSCALARARRAYREGION(T_FLOAT,   jfloat,   Float,   float
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2904
                            , HOTSPOT_JNI_SETFLOATARRAYREGION_ENTRY(env, array, start, len, (float *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2905
                            HOTSPOT_JNI_SETFLOATARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2906
DEFINE_SETSCALARARRAYREGION(T_DOUBLE,  jdouble,  Double,  double
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2907
                            , HOTSPOT_JNI_SETDOUBLEARRAYREGION_ENTRY(env, array, start, len, (double *) buf),
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2908
                            HOTSPOT_JNI_SETDOUBLEARRAYREGION_RETURN())
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2909
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2910
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2911
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2912
// Interception of natives
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2913
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2914
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2915
// The RegisterNatives call being attempted tried to register with a method that
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2916
// is not native.  Ask JVM TI what prefixes have been specified.  Then check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2917
// to see if the native method is now wrapped with the prefixes.  See the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2918
// SetNativeMethodPrefix(es) functions in the JVM TI Spec for details.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2919
static Method* find_prefixed_native(Klass* k, Symbol* name, Symbol* signature, TRAPS) {
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2920
#if INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
  ResourceMark rm(THREAD);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2922
  Method* method;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2923
  int name_len = name->utf8_length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2924
  char* name_str = name->as_utf8();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2925
  int prefix_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2926
  char** prefixes = JvmtiExport::get_all_native_method_prefixes(&prefix_count);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2927
  for (int i = 0; i < prefix_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2928
    char* prefix = prefixes[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2929
    int prefix_len = (int)strlen(prefix);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2930
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2931
    // try adding this prefix to the method name and see if it matches another method name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2932
    int trial_len = name_len + prefix_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2933
    char* trial_name_str = NEW_RESOURCE_ARRAY(char, trial_len + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2934
    strcpy(trial_name_str, prefix);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2935
    strcat(trial_name_str, name_str);
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2936
    TempNewSymbol trial_name = SymbolTable::probe(trial_name_str, trial_len);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  2937
    if (trial_name == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2938
      continue; // no such symbol, so this prefix wasn't used, try the next prefix
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2939
    }
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2940
    method = k->lookup_method(trial_name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2941
    if (method == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2942
      continue; // signature doesn't match, try the next prefix
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2943
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2944
    if (method->is_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2945
      method->set_is_prefixed_native();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2946
      return method; // wahoo, we found a prefixed version of the method, return it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2947
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2948
    // found as non-native, so prefix is good, add it, probably just need more prefixes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2949
    name_len = trial_len;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2950
    name_str = trial_name_str;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2951
  }
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  2952
#endif // INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2953
  return NULL; // not found
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2954
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2955
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2956
static bool register_native(Klass* k, Symbol* name, Symbol* signature, address entry, TRAPS) {
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2957
  Method* method = k->lookup_method(name, signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2958
  if (method == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2959
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2960
    stringStream st;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2961
    st.print("Method %s name or signature does not match",
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2962
             Method::name_and_sig_as_C_string(k, name, signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2963
    THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2964
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2965
  if (!method->is_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2966
    // trying to register to a non-native method, see if a JVM TI agent has added prefix(es)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2967
    method = find_prefixed_native(k, name, signature, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2968
    if (method == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2969
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2970
      stringStream st;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2971
      st.print("Method %s is not declared as native",
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  2972
               Method::name_and_sig_as_C_string(k, name, signature));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2973
      THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2974
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2975
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2976
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2977
  if (entry != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2978
    method->set_native_function(entry,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  2979
      Method::native_bind_event_is_interesting);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2980
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2981
    method->clear_native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2982
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2983
  if (PrintJNIResolving) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2984
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2985
    tty->print_cr("[Registering JNI native method %s.%s]",
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13977
diff changeset
  2986
      method->method_holder()->external_name(),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2987
      method->name()->as_C_string());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2988
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2989
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2990
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2991
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2992
DT_RETURN_MARK_DECL(RegisterNatives, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  2993
                    , HOTSPOT_JNI_REGISTERNATIVES_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2994
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2995
JNI_ENTRY(jint, jni_RegisterNatives(JNIEnv *env, jclass clazz,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2996
                                    const JNINativeMethod *methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2997
                                    jint nMethods))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2998
  JNIWrapper("RegisterNatives");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  2999
  HOTSPOT_JNI_REGISTERNATIVES_ENTRY(env, clazz, (void *) methods, nMethods);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3000
  jint ret = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3001
  DT_RETURN_MARK(RegisterNatives, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3002
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  3003
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3004
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3005
  for (int index = 0; index < nMethods; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3006
    const char* meth_name = methods[index].name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3007
    const char* meth_sig = methods[index].signature;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3008
    int meth_name_len = (int)strlen(meth_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3010
    // The class should have been loaded (we have an instance of the class
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3011
    // passed in) so the method and signature should already be in the symbol
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3012
    // table.  If they're not there, the method doesn't exist.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3013
    TempNewSymbol  name = SymbolTable::probe(meth_name, meth_name_len);
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3014
    TempNewSymbol  signature = SymbolTable::probe(meth_sig, (int)strlen(meth_sig));
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3015
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3016
    if (name == NULL || signature == NULL) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3017
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3018
      stringStream st;
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  3019
      st.print("Method %s.%s%s not found", k->external_name(), meth_name, meth_sig);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3020
      // Must return negative value on failure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3021
      THROW_MSG_(vmSymbols::java_lang_NoSuchMethodError(), st.as_string(), -1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3022
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3023
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 43969
diff changeset
  3024
    bool res = register_native(k, name, signature,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3025
                               (address) methods[index].fnPtr, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3026
    if (!res) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3027
      ret = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3028
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3029
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3030
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3031
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3032
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3035
JNI_ENTRY(jint, jni_UnregisterNatives(JNIEnv *env, jclass clazz))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3036
  JNIWrapper("UnregisterNatives");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3037
 HOTSPOT_JNI_UNREGISTERNATIVES_ENTRY(env, clazz);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3038
  Klass* k   = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3039
  //%note jni_2
33611
9abd65805e19 8139203: Consistent naming for klass type predicates
coleenp
parents: 33576
diff changeset
  3040
  if (k->is_instance_klass()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3041
    for (int index = 0; index < InstanceKlass::cast(k)->methods()->length(); index++) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3042
      Method* m = InstanceKlass::cast(k)->methods()->at(index);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3043
      if (m->is_native()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3044
        m->clear_native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3045
        m->set_signature_handler(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3046
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3047
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3048
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3049
 HOTSPOT_JNI_UNREGISTERNATIVES_RETURN(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3050
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3051
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3052
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3053
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3054
// Monitor functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3055
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3056
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3057
DT_RETURN_MARK_DECL(MonitorEnter, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3058
                    , HOTSPOT_JNI_MONITORENTER_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3059
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3060
JNI_ENTRY(jint, jni_MonitorEnter(JNIEnv *env, jobject jobj))
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3061
 HOTSPOT_JNI_MONITORENTER_ENTRY(env, jobj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3062
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3063
  DT_RETURN_MARK(MonitorEnter, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3064
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3065
  // If the object is null, we can't do anything with it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3066
  if (jobj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3067
    THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3068
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3069
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3070
  Handle obj(thread, JNIHandles::resolve_non_null(jobj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3071
  ObjectSynchronizer::jni_enter(obj, CHECK_(JNI_ERR));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3072
  ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3073
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3074
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3075
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3076
DT_RETURN_MARK_DECL(MonitorExit, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3077
                    , HOTSPOT_JNI_MONITOREXIT_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3078
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3079
JNI_ENTRY(jint, jni_MonitorExit(JNIEnv *env, jobject jobj))
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3080
 HOTSPOT_JNI_MONITOREXIT_ENTRY(env, jobj);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3081
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3082
  DT_RETURN_MARK(MonitorExit, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3083
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3084
  // Don't do anything with a null object
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3085
  if (jobj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3086
    THROW_(vmSymbols::java_lang_NullPointerException(), JNI_ERR);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3087
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3088
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3089
  Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3090
  ObjectSynchronizer::jni_exit(obj(), CHECK_(JNI_ERR));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3091
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3092
  ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3093
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3094
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3096
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3097
// Extensions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3098
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3099
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3100
DT_VOID_RETURN_MARK_DECL(GetStringRegion
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3101
                         , HOTSPOT_JNI_GETSTRINGREGION_RETURN());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3102
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3103
JNI_ENTRY(void, jni_GetStringRegion(JNIEnv *env, jstring string, jsize start, jsize len, jchar *buf))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3104
  JNIWrapper("GetStringRegion");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3105
 HOTSPOT_JNI_GETSTRINGREGION_ENTRY(env, string, start, len, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3106
  DT_VOID_RETURN_MARK(GetStringRegion);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3107
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3108
  int s_len = java_lang_String::length(s);
48558
b2b67c8fc91a 8181664: Improve JVM UTF String handling
rprotacio
parents: 48105
diff changeset
  3109
  if (start < 0 || len < 0 || start > s_len - len) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3110
    THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3111
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3112
    if (len > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3113
      typeArrayOop s_value = java_lang_String::value(s);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3114
      bool is_latin1 = java_lang_String::is_latin1(s);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3115
      if (!is_latin1) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3116
        memcpy(buf, s_value->char_at_addr(start), sizeof(jchar)*len);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3117
      } else {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3118
        for (int i = 0; i < len; i++) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3119
          buf[i] = ((jchar) s_value->byte_at(i + start)) & 0xff;
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3120
        }
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3121
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3122
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3123
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3124
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3125
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3126
DT_VOID_RETURN_MARK_DECL(GetStringUTFRegion
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3127
                         , HOTSPOT_JNI_GETSTRINGUTFREGION_RETURN());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3128
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3129
JNI_ENTRY(void, jni_GetStringUTFRegion(JNIEnv *env, jstring string, jsize start, jsize len, char *buf))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3130
  JNIWrapper("GetStringUTFRegion");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3131
 HOTSPOT_JNI_GETSTRINGUTFREGION_ENTRY(env, string, start, len, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3132
  DT_VOID_RETURN_MARK(GetStringUTFRegion);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3133
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3134
  int s_len = java_lang_String::length(s);
48558
b2b67c8fc91a 8181664: Improve JVM UTF String handling
rprotacio
parents: 48105
diff changeset
  3135
  if (start < 0 || len < 0 || start > s_len - len) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3136
    THROW(vmSymbols::java_lang_StringIndexOutOfBoundsException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3137
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3138
    //%note jni_7
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3139
    if (len > 0) {
24237
7b210ef8c830 6664815: Eliminate redundant memcpy operation in jni_GetStringUTFRegion
mgerdin
parents: 23997
diff changeset
  3140
      // Assume the buffer is large enough as the JNI spec. does not require user error checking
7b210ef8c830 6664815: Eliminate redundant memcpy operation in jni_GetStringUTFRegion
mgerdin
parents: 23997
diff changeset
  3141
      java_lang_String::as_utf8_string(s, start, len, buf, INT_MAX);
7b210ef8c830 6664815: Eliminate redundant memcpy operation in jni_GetStringUTFRegion
mgerdin
parents: 23997
diff changeset
  3142
      // as_utf8_string null-terminates the result string
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3143
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3144
      // JDK null-terminates the buffer even in len is zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3145
      if (buf != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3146
        buf[0] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3147
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3148
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3149
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3150
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3151
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3152
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3153
JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3154
  JNIWrapper("GetPrimitiveArrayCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3155
 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy);
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3156
  GCLocker::lock_critical(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3157
  if (isCopy != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3158
    *isCopy = JNI_FALSE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3159
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3160
  oop a = JNIHandles::resolve_non_null(array);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3161
  assert(a->is_array(), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
  BasicType type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
  if (a->is_objArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
    type = T_OBJECT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
  } else {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
  3166
    type = TypeArrayKlass::cast(a->klass())->element_type();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3167
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
  void* ret = arrayOop(a)->base(type);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3169
 HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3170
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3171
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3174
JNI_ENTRY(void, jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3175
  JNIWrapper("ReleasePrimitiveArrayCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3176
  HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
  // The array, carray and mode arguments are ignored
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3178
  GCLocker::unlock_critical(thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3179
HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
  JNIWrapper("GetStringCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3185
  HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy);
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3186
  GCLocker::lock_critical(thread);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
  oop s = JNIHandles::resolve_non_null(string);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
  typeArrayOop s_value = java_lang_String::value(s);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3189
  bool is_latin1 = java_lang_String::is_latin1(s);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3190
  if (isCopy != NULL) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3191
    *isCopy = is_latin1 ? JNI_TRUE : JNI_FALSE;
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3192
  }
35162
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3193
  jchar* ret;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3194
  if (!is_latin1) {
35162
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3195
    ret = (jchar*) s_value->base(T_CHAR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3196
  } else {
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3197
    // Inflate latin1 encoded string to UTF16
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3198
    int s_len = java_lang_String::length(s);
35162
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3199
    ret = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal);  // add one for zero termination
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3200
    /* JNI Specification states return NULL on OOM */
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3201
    if (ret != NULL) {
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3202
      for (int i = 0; i < s_len; i++) {
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3203
        ret[i] = ((jchar) s_value->byte_at(i)) & 0xff;
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3204
      }
65d0237246b1 8145015: jni_GetStringCritical asserts for empty strings
simonis
parents: 35061
diff changeset
  3205
      ret[s_len] = 0;
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3206
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3207
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3208
 HOTSPOT_JNI_GETSTRINGCRITICAL_RETURN((uint16_t *) ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3209
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3210
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3211
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3213
JNI_ENTRY(void, jni_ReleaseStringCritical(JNIEnv *env, jstring str, const jchar *chars))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3214
  JNIWrapper("ReleaseStringCritical");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3215
  HOTSPOT_JNI_RELEASESTRINGCRITICAL_ENTRY(env, str, (uint16_t *) chars);
33628
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3216
  // The str and chars arguments are ignored for UTF16 strings
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3217
  oop s = JNIHandles::resolve_non_null(str);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3218
  bool is_latin1 = java_lang_String::is_latin1(s);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3219
  if (is_latin1) {
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3220
    // For latin1 string, free jchar array allocated by earlier call to GetStringCritical.
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3221
    // This assumes that ReleaseStringCritical bookends GetStringCritical.
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3222
    FREE_C_HEAP_ARRAY(jchar, chars);
09241459a8b8 8141132: JEP 254: Compact Strings
thartmann
parents: 33470
diff changeset
  3223
  }
35492
c8c0273e6b91 8146690: Make all classes in GC follow the naming convention.
david
parents: 35219
diff changeset
  3224
  GCLocker::unlock_critical(thread);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3225
HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3226
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3227
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3228
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3229
JNI_ENTRY(jweak, jni_NewWeakGlobalRef(JNIEnv *env, jobject ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3230
  JNIWrapper("jni_NewWeakGlobalRef");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3231
 HOTSPOT_JNI_NEWWEAKGLOBALREF_ENTRY(env, ref);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3232
  Handle ref_handle(thread, JNIHandles::resolve(ref));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3233
  jweak ret = JNIHandles::make_weak_global(ref_handle);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3234
 HOTSPOT_JNI_NEWWEAKGLOBALREF_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3235
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3236
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3237
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3238
// Must be JNI_ENTRY (with HandleMark)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3239
JNI_ENTRY(void, jni_DeleteWeakGlobalRef(JNIEnv *env, jweak ref))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3240
  JNIWrapper("jni_DeleteWeakGlobalRef");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3241
  HOTSPOT_JNI_DELETEWEAKGLOBALREF_ENTRY(env, ref);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3242
  JNIHandles::destroy_weak_global(ref);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3243
  HOTSPOT_JNI_DELETEWEAKGLOBALREF_RETURN();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3244
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3245
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3246
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3247
JNI_QUICK_ENTRY(jboolean, jni_ExceptionCheck(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3248
  JNIWrapper("jni_ExceptionCheck");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3249
 HOTSPOT_JNI_EXCEPTIONCHECK_ENTRY(env);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3250
  jni_check_async_exceptions(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3251
  jboolean ret = (thread->has_pending_exception()) ? JNI_TRUE : JNI_FALSE;
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3252
 HOTSPOT_JNI_EXCEPTIONCHECK_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3253
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3254
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3255
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3256
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3257
// Initialization state for three routines below relating to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3258
// java.nio.DirectBuffers
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  3259
static          int directBufferSupportInitializeStarted = 0;
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  3260
static volatile int directBufferSupportInitializeEnded   = 0;
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  3261
static volatile int directBufferSupportInitializeFailed  = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3262
static jclass    bufferClass                 = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3263
static jclass    directBufferClass           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3264
static jclass    directByteBufferClass       = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3265
static jmethodID directByteBufferConstructor = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3266
static jfieldID  directBufferAddressField    = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3267
static jfieldID  bufferCapacityField         = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3268
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3269
static jclass lookupOne(JNIEnv* env, const char* name, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3270
  Handle loader;            // null (bootstrap) loader
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3271
  Handle protection_domain; // null protection domain
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3272
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7414
diff changeset
  3273
  TempNewSymbol sym = SymbolTable::new_symbol(name, CHECK_NULL);
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3274
  jclass result =  find_class_from_class_loader(env, sym, true, loader, protection_domain, true, CHECK_NULL);
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3275
38151
fffedc5e5cf8 8154110: Update class* and safepoint* logging subsystems
mockner
parents: 37483
diff changeset
  3276
  if (log_is_enabled(Debug, class, resolve) && result != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
  3277
    trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
2269
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3278
  }
ee9da33d43ab 6603316: Improve instrumentation for classes loaded at startup
acorn
parents: 2105
diff changeset
  3279
  return result;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3280
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3281
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3282
// These lookups are done with the NULL (bootstrap) ClassLoader to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3283
// circumvent any security checks that would be done by jni_FindClass.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3284
JNI_ENTRY(bool, lookupDirectBufferClasses(JNIEnv* env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3285
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3286
  if ((bufferClass           = lookupOne(env, "java/nio/Buffer", thread))           == NULL) { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3287
  if ((directBufferClass     = lookupOne(env, "sun/nio/ch/DirectBuffer", thread))   == NULL) { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3288
  if ((directByteBufferClass = lookupOne(env, "java/nio/DirectByteBuffer", thread)) == NULL) { return false; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3289
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3290
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3291
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3292
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3293
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3294
static bool initializeDirectBufferSupport(JNIEnv* env, JavaThread* thread) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3295
  if (directBufferSupportInitializeFailed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3296
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3297
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3298
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3299
  if (Atomic::cmpxchg(1, &directBufferSupportInitializeStarted, 0) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3300
    if (!lookupDirectBufferClasses(env)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3301
      directBufferSupportInitializeFailed = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3302
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3303
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3304
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3305
    // Make global references for these
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3306
    bufferClass           = (jclass) env->NewGlobalRef(bufferClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3307
    directBufferClass     = (jclass) env->NewGlobalRef(directBufferClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3308
    directByteBufferClass = (jclass) env->NewGlobalRef(directByteBufferClass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3309
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3310
    // Get needed field and method IDs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3311
    directByteBufferConstructor = env->GetMethodID(directByteBufferClass, "<init>", "(JI)V");
22786
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3312
    if (env->ExceptionCheck()) {
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3313
      env->ExceptionClear();
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3314
      directBufferSupportInitializeFailed = 1;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3315
      return false;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3316
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3317
    directBufferAddressField    = env->GetFieldID(bufferClass, "address", "J");
22786
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3318
    if (env->ExceptionCheck()) {
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3319
      env->ExceptionClear();
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3320
      directBufferSupportInitializeFailed = 1;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3321
      return false;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3322
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3323
    bufferCapacityField         = env->GetFieldID(bufferClass, "capacity", "I");
22786
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3324
    if (env->ExceptionCheck()) {
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3325
      env->ExceptionClear();
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3326
      directBufferSupportInitializeFailed = 1;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3327
      return false;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 22737
diff changeset
  3328
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3329
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3330
    if ((directByteBufferConstructor == NULL) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3331
        (directBufferAddressField    == NULL) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3332
        (bufferCapacityField         == NULL)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3333
      directBufferSupportInitializeFailed = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3334
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3335
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3337
    directBufferSupportInitializeEnded = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3338
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3339
    while (!directBufferSupportInitializeEnded && !directBufferSupportInitializeFailed) {
25477
7dad9f95fd31 8047714: Fix for JDK-6546236 made Solaris os::yield() a no-op
fparain
parents: 25469
diff changeset
  3340
      os::naked_yield();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3341
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3342
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3343
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3344
  return !directBufferSupportInitializeFailed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3345
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3347
extern "C" jobject JNICALL jni_NewDirectByteBuffer(JNIEnv *env, void* address, jlong capacity)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3348
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3349
  // thread_from_jni_environment() will block if VM is gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3350
  JavaThread* thread = JavaThread::thread_from_jni_environment(env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3351
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3352
  JNIWrapper("jni_NewDirectByteBuffer");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3353
 HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_ENTRY(env, address, capacity);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3354
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3355
  if (!directBufferSupportInitializeEnded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3356
    if (!initializeDirectBufferSupport(env, thread)) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3357
      HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3358
      return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3359
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3360
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3361
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3362
  // Being paranoid about accidental sign extension on address
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3363
  jlong addr = (jlong) ((uintptr_t) address);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3364
  // NOTE that package-private DirectByteBuffer constructor currently
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3365
  // takes int capacity
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3366
  jint  cap  = (jint)  capacity;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3367
  jobject ret = env->NewObject(directByteBufferClass, directByteBufferConstructor, addr, cap);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3368
  HOTSPOT_JNI_NEWDIRECTBYTEBUFFER_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3369
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3370
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3371
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3372
DT_RETURN_MARK_DECL(GetDirectBufferAddress, void*
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3373
                    , HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_RETURN((void*) _ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3374
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3375
extern "C" void* JNICALL jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3376
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3377
  // thread_from_jni_environment() will block if VM is gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3378
  JavaThread* thread = JavaThread::thread_from_jni_environment(env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3379
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3380
  JNIWrapper("jni_GetDirectBufferAddress");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3381
  HOTSPOT_JNI_GETDIRECTBUFFERADDRESS_ENTRY(env, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3382
  void* ret = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3383
  DT_RETURN_MARK(GetDirectBufferAddress, void*, (const void*&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3384
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3385
  if (!directBufferSupportInitializeEnded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3386
    if (!initializeDirectBufferSupport(env, thread)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3387
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3388
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3389
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3390
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3391
  if ((buf != NULL) && (!env->IsInstanceOf(buf, directBufferClass))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3392
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3393
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3394
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3395
  ret = (void*)(intptr_t)env->GetLongField(buf, directBufferAddressField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3396
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3397
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3398
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3399
DT_RETURN_MARK_DECL(GetDirectBufferCapacity, jlong
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3400
                    , HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3401
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3402
extern "C" jlong JNICALL jni_GetDirectBufferCapacity(JNIEnv *env, jobject buf)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3403
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3404
  // thread_from_jni_environment() will block if VM is gone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3405
  JavaThread* thread = JavaThread::thread_from_jni_environment(env);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3406
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3407
  JNIWrapper("jni_GetDirectBufferCapacity");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3408
  HOTSPOT_JNI_GETDIRECTBUFFERCAPACITY_ENTRY(env, buf);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3409
  jlong ret = -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3410
  DT_RETURN_MARK(GetDirectBufferCapacity, jlong, (const jlong&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3411
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3412
  if (!directBufferSupportInitializeEnded) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3413
    if (!initializeDirectBufferSupport(env, thread)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3414
      ret = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3415
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3416
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3417
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3418
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3419
  if (buf == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3420
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3421
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3423
  if (!env->IsInstanceOf(buf, directBufferClass)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3424
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3425
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3426
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3427
  // NOTE that capacity is currently an int in the implementation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3428
  ret = env->GetIntField(buf, bufferCapacityField);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3429
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3430
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3431
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3432
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3433
JNI_LEAF(jint, jni_GetVersion(JNIEnv *env))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3434
  JNIWrapper("GetVersion");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3435
  HOTSPOT_JNI_GETVERSION_ENTRY(env);
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3436
  HOTSPOT_JNI_GETVERSION_RETURN(CurrentVersion);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3437
  return CurrentVersion;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3438
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3439
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3440
extern struct JavaVM_ main_vm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3441
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3442
JNI_LEAF(jint, jni_GetJavaVM(JNIEnv *env, JavaVM **vm))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3443
  JNIWrapper("jni_GetJavaVM");
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3444
  HOTSPOT_JNI_GETJAVAVM_ENTRY(env, (void **) vm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3445
  *vm  = (JavaVM *)(&main_vm);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3446
  HOTSPOT_JNI_GETJAVAVM_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3447
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3448
JNI_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3449
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3450
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3451
JNI_ENTRY(jobject, jni_GetModule(JNIEnv* env, jclass clazz))
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3452
  JNIWrapper("GetModule");
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3453
  return Modules::get_module(clazz, THREAD);
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3454
JNI_END
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3455
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3456
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3457
// Structure containing all jni functions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3458
struct JNINativeInterface_ jni_NativeInterface = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3459
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3460
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3461
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3462
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3463
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3464
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3465
    jni_GetVersion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3466
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3467
    jni_DefineClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3468
    jni_FindClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3469
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3470
    jni_FromReflectedMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3471
    jni_FromReflectedField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3472
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3473
    jni_ToReflectedMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3474
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3475
    jni_GetSuperclass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3476
    jni_IsAssignableFrom,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3477
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3478
    jni_ToReflectedField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3479
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3480
    jni_Throw,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3481
    jni_ThrowNew,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3482
    jni_ExceptionOccurred,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3483
    jni_ExceptionDescribe,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3484
    jni_ExceptionClear,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3485
    jni_FatalError,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3486
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3487
    jni_PushLocalFrame,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3488
    jni_PopLocalFrame,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3489
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3490
    jni_NewGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3491
    jni_DeleteGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3492
    jni_DeleteLocalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3493
    jni_IsSameObject,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3494
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3495
    jni_NewLocalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3496
    jni_EnsureLocalCapacity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3497
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3498
    jni_AllocObject,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3499
    jni_NewObject,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3500
    jni_NewObjectV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3501
    jni_NewObjectA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3502
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3503
    jni_GetObjectClass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3504
    jni_IsInstanceOf,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3505
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3506
    jni_GetMethodID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3507
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3508
    jni_CallObjectMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3509
    jni_CallObjectMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3510
    jni_CallObjectMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3511
    jni_CallBooleanMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3512
    jni_CallBooleanMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3513
    jni_CallBooleanMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3514
    jni_CallByteMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3515
    jni_CallByteMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3516
    jni_CallByteMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3517
    jni_CallCharMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3518
    jni_CallCharMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3519
    jni_CallCharMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3520
    jni_CallShortMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3521
    jni_CallShortMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3522
    jni_CallShortMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3523
    jni_CallIntMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3524
    jni_CallIntMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3525
    jni_CallIntMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3526
    jni_CallLongMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3527
    jni_CallLongMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3528
    jni_CallLongMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3529
    jni_CallFloatMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3530
    jni_CallFloatMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3531
    jni_CallFloatMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3532
    jni_CallDoubleMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3533
    jni_CallDoubleMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3534
    jni_CallDoubleMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3535
    jni_CallVoidMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3536
    jni_CallVoidMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3537
    jni_CallVoidMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3538
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3539
    jni_CallNonvirtualObjectMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3540
    jni_CallNonvirtualObjectMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3541
    jni_CallNonvirtualObjectMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3542
    jni_CallNonvirtualBooleanMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3543
    jni_CallNonvirtualBooleanMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3544
    jni_CallNonvirtualBooleanMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3545
    jni_CallNonvirtualByteMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3546
    jni_CallNonvirtualByteMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3547
    jni_CallNonvirtualByteMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3548
    jni_CallNonvirtualCharMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3549
    jni_CallNonvirtualCharMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3550
    jni_CallNonvirtualCharMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3551
    jni_CallNonvirtualShortMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3552
    jni_CallNonvirtualShortMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3553
    jni_CallNonvirtualShortMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3554
    jni_CallNonvirtualIntMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3555
    jni_CallNonvirtualIntMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3556
    jni_CallNonvirtualIntMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3557
    jni_CallNonvirtualLongMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3558
    jni_CallNonvirtualLongMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3559
    jni_CallNonvirtualLongMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3560
    jni_CallNonvirtualFloatMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3561
    jni_CallNonvirtualFloatMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3562
    jni_CallNonvirtualFloatMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3563
    jni_CallNonvirtualDoubleMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3564
    jni_CallNonvirtualDoubleMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3565
    jni_CallNonvirtualDoubleMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3566
    jni_CallNonvirtualVoidMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3567
    jni_CallNonvirtualVoidMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3568
    jni_CallNonvirtualVoidMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3569
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3570
    jni_GetFieldID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3571
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3572
    jni_GetObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3573
    jni_GetBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3574
    jni_GetByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3575
    jni_GetCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3576
    jni_GetShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3577
    jni_GetIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3578
    jni_GetLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3579
    jni_GetFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3580
    jni_GetDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3581
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3582
    jni_SetObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3583
    jni_SetBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3584
    jni_SetByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3585
    jni_SetCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3586
    jni_SetShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3587
    jni_SetIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3588
    jni_SetLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3589
    jni_SetFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3590
    jni_SetDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3591
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3592
    jni_GetStaticMethodID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3593
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3594
    jni_CallStaticObjectMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3595
    jni_CallStaticObjectMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3596
    jni_CallStaticObjectMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3597
    jni_CallStaticBooleanMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3598
    jni_CallStaticBooleanMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3599
    jni_CallStaticBooleanMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3600
    jni_CallStaticByteMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3601
    jni_CallStaticByteMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3602
    jni_CallStaticByteMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3603
    jni_CallStaticCharMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3604
    jni_CallStaticCharMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3605
    jni_CallStaticCharMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3606
    jni_CallStaticShortMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3607
    jni_CallStaticShortMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3608
    jni_CallStaticShortMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3609
    jni_CallStaticIntMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3610
    jni_CallStaticIntMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3611
    jni_CallStaticIntMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3612
    jni_CallStaticLongMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3613
    jni_CallStaticLongMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3614
    jni_CallStaticLongMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3615
    jni_CallStaticFloatMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3616
    jni_CallStaticFloatMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3617
    jni_CallStaticFloatMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3618
    jni_CallStaticDoubleMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3619
    jni_CallStaticDoubleMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3620
    jni_CallStaticDoubleMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3621
    jni_CallStaticVoidMethod,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3622
    jni_CallStaticVoidMethodV,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3623
    jni_CallStaticVoidMethodA,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3624
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3625
    jni_GetStaticFieldID,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3626
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3627
    jni_GetStaticObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3628
    jni_GetStaticBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3629
    jni_GetStaticByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3630
    jni_GetStaticCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3631
    jni_GetStaticShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3632
    jni_GetStaticIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3633
    jni_GetStaticLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3634
    jni_GetStaticFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3635
    jni_GetStaticDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3636
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3637
    jni_SetStaticObjectField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3638
    jni_SetStaticBooleanField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3639
    jni_SetStaticByteField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3640
    jni_SetStaticCharField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3641
    jni_SetStaticShortField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3642
    jni_SetStaticIntField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3643
    jni_SetStaticLongField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3644
    jni_SetStaticFloatField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3645
    jni_SetStaticDoubleField,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3646
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3647
    jni_NewString,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3648
    jni_GetStringLength,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3649
    jni_GetStringChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3650
    jni_ReleaseStringChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3651
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3652
    jni_NewStringUTF,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3653
    jni_GetStringUTFLength,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3654
    jni_GetStringUTFChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3655
    jni_ReleaseStringUTFChars,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3656
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3657
    jni_GetArrayLength,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3658
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3659
    jni_NewObjectArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3660
    jni_GetObjectArrayElement,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3661
    jni_SetObjectArrayElement,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3662
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3663
    jni_NewBooleanArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3664
    jni_NewByteArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3665
    jni_NewCharArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3666
    jni_NewShortArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3667
    jni_NewIntArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3668
    jni_NewLongArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3669
    jni_NewFloatArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3670
    jni_NewDoubleArray,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3671
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3672
    jni_GetBooleanArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3673
    jni_GetByteArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3674
    jni_GetCharArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3675
    jni_GetShortArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3676
    jni_GetIntArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3677
    jni_GetLongArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3678
    jni_GetFloatArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3679
    jni_GetDoubleArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3680
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3681
    jni_ReleaseBooleanArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3682
    jni_ReleaseByteArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3683
    jni_ReleaseCharArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3684
    jni_ReleaseShortArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3685
    jni_ReleaseIntArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3686
    jni_ReleaseLongArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3687
    jni_ReleaseFloatArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3688
    jni_ReleaseDoubleArrayElements,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3689
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3690
    jni_GetBooleanArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3691
    jni_GetByteArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3692
    jni_GetCharArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3693
    jni_GetShortArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3694
    jni_GetIntArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3695
    jni_GetLongArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3696
    jni_GetFloatArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3697
    jni_GetDoubleArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3698
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3699
    jni_SetBooleanArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3700
    jni_SetByteArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3701
    jni_SetCharArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3702
    jni_SetShortArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3703
    jni_SetIntArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3704
    jni_SetLongArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3705
    jni_SetFloatArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3706
    jni_SetDoubleArrayRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3707
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3708
    jni_RegisterNatives,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3709
    jni_UnregisterNatives,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3710
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3711
    jni_MonitorEnter,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3712
    jni_MonitorExit,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3713
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3714
    jni_GetJavaVM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3715
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3716
    jni_GetStringRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3717
    jni_GetStringUTFRegion,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3718
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3719
    jni_GetPrimitiveArrayCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3720
    jni_ReleasePrimitiveArrayCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3721
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3722
    jni_GetStringCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3723
    jni_ReleaseStringCritical,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3724
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3725
    jni_NewWeakGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3726
    jni_DeleteWeakGlobalRef,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3727
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3728
    jni_ExceptionCheck,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3729
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3730
    jni_NewDirectByteBuffer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3731
    jni_GetDirectBufferAddress,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3732
    jni_GetDirectBufferCapacity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3733
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3734
    // New 1_6 features
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3735
36508
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3736
    jni_GetObjectRefType,
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3737
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3738
    // Module features
5f9eee6b383b 8142968: Module System implementation
alanb
parents: 36396
diff changeset
  3739
42307
cefc81dc1d52 8169069: Module system implementation refresh (11/2016)
alanb
parents: 41669
diff changeset
  3740
    jni_GetModule
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3741
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3742
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3743
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3744
// For jvmti use to modify jni function table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3745
// Java threads in native contiues to run until it is transitioned
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3746
// to VM at safepoint. Before the transition or before it is blocked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3747
// for safepoint it may access jni function table. VM could crash if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3748
// any java thread access the jni function table in the middle of memcpy.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3749
// To avoid this each function pointers are copied automically.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3750
void copy_jni_function_table(const struct JNINativeInterface_ *new_jni_NativeInterface) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3751
  assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3752
  intptr_t *a = (intptr_t *) jni_functions();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3753
  intptr_t *b = (intptr_t *) new_jni_NativeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3754
  for (uint i=0; i <  sizeof(struct JNINativeInterface_)/sizeof(void *); i++) {
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47627
diff changeset
  3755
    Atomic::store(*b++, a++);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3756
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3757
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3758
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3759
void quicken_jni_functions() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3760
  // Replace Get<Primitive>Field with fast versions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3761
  if (UseFastJNIAccessors && !JvmtiExport::can_post_field_access()
34285
0b07014c15e9 8143155: Remove TraceRuntimeCalls, TraceJNICalls, and TraceJVMCalls rather than convert to UL
rprotacio
parents: 33813
diff changeset
  3762
      && !VerifyJNIFields && !CountJNICalls && !CheckJNICalls
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3763
#if defined(_WINDOWS) && defined(IA32) && defined(COMPILER2)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3764
      // windows x86 currently needs SEH wrapper and the gain of the fast
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3765
      // versions currently isn't certain for server vm on uniprocessor.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3766
      && os::is_MP()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3767
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3768
  ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3769
    address func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3770
    func = JNI_FastGetField::generate_fast_get_boolean_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3771
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3772
      jni_NativeInterface.GetBooleanField = (GetBooleanField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3773
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3774
    func = JNI_FastGetField::generate_fast_get_byte_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3775
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3776
      jni_NativeInterface.GetByteField = (GetByteField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3777
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3778
    func = JNI_FastGetField::generate_fast_get_char_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3779
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3780
      jni_NativeInterface.GetCharField = (GetCharField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3781
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3782
    func = JNI_FastGetField::generate_fast_get_short_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3783
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3784
      jni_NativeInterface.GetShortField = (GetShortField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3785
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3786
    func = JNI_FastGetField::generate_fast_get_int_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3787
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3788
      jni_NativeInterface.GetIntField = (GetIntField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3789
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3790
    func = JNI_FastGetField::generate_fast_get_long_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3791
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3792
      jni_NativeInterface.GetLongField = (GetLongField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3793
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3794
    func = JNI_FastGetField::generate_fast_get_float_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3795
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3796
      jni_NativeInterface.GetFloatField = (GetFloatField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3797
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3798
    func = JNI_FastGetField::generate_fast_get_double_field();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3799
    if (func != (address)-1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3800
      jni_NativeInterface.GetDoubleField = (GetDoubleField_t)func;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3801
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3802
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3803
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3804
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3805
// Returns the function structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3806
struct JNINativeInterface_* jni_functions() {
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  3807
#if INCLUDE_JNI_CHECK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3808
  if (CheckJNICalls) return jni_functions_check();
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
  3809
#endif // INCLUDE_JNI_CHECK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3810
  return &jni_NativeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3811
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3812
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3813
// Returns the function structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3814
struct JNINativeInterface_* jni_functions_nocheck() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3815
  return &jni_NativeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3816
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3817
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3818
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3819
// Invocation API
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3820
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3822
// Forward declaration
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3823
extern const struct JNIInvokeInterface_ jni_InvokeInterface;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3824
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3825
// Global invocation API vars
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  3826
volatile int vm_created = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3827
// Indicate whether it is safe to recreate VM
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  3828
volatile int safe_to_recreate_vm = 1;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3829
struct JavaVM_ main_vm = {&jni_InvokeInterface};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3830
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3831
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3832
#define JAVASTACKSIZE (400 * 1024)    /* Default size of a thread java stack */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3833
enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3834
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3835
DT_RETURN_MARK_DECL(GetDefaultJavaVMInitArgs, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3836
                    , HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3837
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3838
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3839
  HOTSPOT_JNI_GETDEFAULTJAVAVMINITARGS_ENTRY(args_);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3840
  JDK1_1InitArgs *args = (JDK1_1InitArgs *)args_;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3841
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3842
  DT_RETURN_MARK(GetDefaultJavaVMInitArgs, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3843
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3844
  if (Threads::is_supported_jni_version(args->version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3845
    ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3846
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3847
  // 1.1 style no longer supported in hotspot.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3848
  // According the JNI spec, we should update args->version on return.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3849
  // We also use the structure to communicate with launcher about default
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3850
  // stack size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3851
  if (args->version == JNI_VERSION_1_1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3852
    args->version = JNI_VERSION_1_2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3853
    // javaStackSize is int in arguments structure
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3854
    assert(jlong(ThreadStackSize) * K < INT_MAX, "integer overflow");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3855
    args->javaStackSize = (jint)(ThreadStackSize * K);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3856
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3857
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3858
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3859
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3860
DT_RETURN_MARK_DECL(CreateJavaVM, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  3861
                    , HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3862
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  3863
static jint JNI_CreateJavaVM_inner(JavaVM **vm, void **penv, void *args) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  3864
  HOTSPOT_JNI_CREATEJAVAVM_ENTRY((void **) vm, penv, args);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3865
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3866
  jint result = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3867
  DT_RETURN_MARK(CreateJavaVM, jint, (const jint&)result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3868
4448
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3869
  // We're about to use Atomic::xchg for synchronization.  Some Zero
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3870
  // platforms use the GCC builtin __sync_lock_test_and_set for this,
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3871
  // but __sync_lock_test_and_set is not guaranteed to do what we want
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3872
  // on all architectures.  So we check it works before relying on it.
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3873
#if defined(ZERO) && defined(ASSERT)
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3874
  {
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3875
    jint a = 0xcafebabe;
47627
6218d903d2f2 8189333: Fix Zero build after Atomic::xchg changes
rkennke
parents: 47613
diff changeset
  3876
    jint b = Atomic::xchg((jint) 0xdeadbeef, &a);
4448
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3877
    void *c = &a;
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47627
diff changeset
  3878
    void *d = Atomic::xchg(&b, &c);
4561
4dfa5956fbb9 6913869: Zero assert fix
twisti
parents: 4448
diff changeset
  3879
    assert(a == (jint) 0xdeadbeef && b == (jint) 0xcafebabe, "Atomic::xchg() works");
47634
6a0c42c40cd1 8188220: Remove Atomic::*_ptr() uses and overloads from hotspot
coleenp
parents: 47627
diff changeset
  3880
    assert(c == &b && d == &a, "Atomic::xchg() works");
4448
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3881
  }
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3882
#endif // ZERO && ASSERT
d6ec2737186c 6896043: first round of zero fixes
twisti
parents: 4089
diff changeset
  3883
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3884
  // At the moment it's only possible to have one Java VM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3885
  // since some of the runtime state is in global variables.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3886
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3887
  // We cannot use our mutex locks here, since they only work on
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3888
  // Threads. We do an atomic compare and exchange to ensure only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3889
  // one thread can call this method at a time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3890
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3891
  // We use Atomic::xchg rather than Atomic::add/dec since on some platforms
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3892
  // the add/dec implementations are dependent on whether we are running
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3893
  // on a multiprocessor, and at this stage of initialization the os::is_MP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3894
  // function used to determine this will always return false. Atomic::xchg
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3895
  // does not have this problem.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3896
  if (Atomic::xchg(1, &vm_created) == 1) {
18680
6d5dc445baec 8019833: Wrong JNI error code for preexisting JVM
coleenp
parents: 18486
diff changeset
  3897
    return JNI_EEXIST;   // already created, or create attempt in progress
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3898
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3899
  if (Atomic::xchg(0, &safe_to_recreate_vm) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3900
    return JNI_ERR;  // someone tried and failed and retry not allowed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3901
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3902
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3903
  assert(vm_created == 1, "vm_created is true during the creation");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3904
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3905
  /**
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3906
   * Certain errors during initialization are recoverable and do not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3907
   * prevent this method from being called again at a later time
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3908
   * (perhaps with different arguments).  However, at a certain
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3909
   * point during initialization if an error occurs we cannot allow
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3910
   * this function to be called again (or it will crash).  In those
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3911
   * situations, the 'canTryAgain' flag is set to false, which atomically
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3912
   * sets safe_to_recreate_vm to 1, such that any new call to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3913
   * JNI_CreateJavaVM will immediately fail using the above logic.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3914
   */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3915
  bool can_try_again = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3916
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3917
  result = Threads::create_vm((JavaVMInitArgs*) args, &can_try_again);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3918
  if (result == JNI_OK) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3919
    JavaThread *thread = JavaThread::current();
22539
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3920
    assert(!thread->has_pending_exception(), "should have returned not OK");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3921
    /* thread is thread_in_vm here */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3922
    *vm = (JavaVM *)(&main_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3923
    *(JNIEnv**)penv = thread->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3924
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3925
#if INCLUDE_JVMCI
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3926
    if (EnableJVMCI) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3927
      if (UseJVMCICompiler) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3928
        // JVMCI is initialized on a CompilerThread
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3929
        if (BootstrapJVMCI) {
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3930
          JavaThread* THREAD = thread;
47796
47629b00daa9 8187315: [JVMCI] hosted use of JVMCI can crash VM under -Xint
dnsimon
parents: 47765
diff changeset
  3931
          JVMCICompiler* compiler = JVMCICompiler::instance(true, CATCH);
38674
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3932
          compiler->bootstrap(THREAD);
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3933
          if (HAS_PENDING_EXCEPTION) {
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3934
            HandleMark hm;
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3935
            vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
eacc567feae8 8156034: [JVMCI] Notify the jvmci compiler on completion of a bootstrap
never
parents: 38151
diff changeset
  3936
          }
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3937
        }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3938
      }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3939
    }
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3940
#endif
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 32598
diff changeset
  3941
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3942
    // Tracks the time application was running before GC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3943
    RuntimeService::record_application_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3944
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3945
    // Notify JVMTI
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3946
    if (JvmtiExport::should_post_thread_life()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3947
       JvmtiExport::post_thread_start(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3948
    }
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  3949
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3950
    EventThreadStart event;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3951
    if (event.should_commit()) {
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 36183
diff changeset
  3952
      event.set_thread(THREAD_TRACE_ID(thread));
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3953
      event.commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  3954
    }
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  3955
18683
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3956
#ifndef PRODUCT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3957
    // Check if we should compile all classes on bootclasspath
18683
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3958
    if (CompileTheWorld) ClassLoader::compile_the_world();
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3959
    if (ReplayCompiles) ciReplay::replay(thread);
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3960
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3961
    // Some platforms (like Win*) need a wrapper around these test
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3962
    // functions in order to properly handle error conditions.
46589
f1c04490ded1 8182848: Some functions misplaced in debug.hpp
coleenp
parents: 46431
diff changeset
  3963
    VMError::test_error_handler();
35519
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
  3964
    if (ExecuteInternalVMTests) {
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
  3965
      InternalVMTests::run();
9200162499f7 8146994: Move internal vm tests to a separate file
ehelin
parents: 35500
diff changeset
  3966
    }
18683
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3967
#endif
a6418e038255 8015884: runThese crashed with SIGSEGV, hs_err has an error instead of stacktrace
dcubed
parents: 18680
diff changeset
  3968
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3969
    // Since this is not a JVM_ENTRY we have to set the thread state manually before leaving.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3970
    ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3971
  } else {
22539
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3972
    // If create_vm exits because of a pending exception, exit with that
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3973
    // exception.  In the future when we figure out how to reclaim memory,
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3974
    // we may be able to exit with JNI_ERR and allow the calling application
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3975
    // to continue.
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3976
    if (Universe::is_fully_initialized()) {
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3977
      // otherwise no pending exception possible - VM will already have aborted
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3978
      JavaThread* THREAD = JavaThread::current();
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3979
      if (HAS_PENDING_EXCEPTION) {
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3980
        HandleMark hm;
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3981
        vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3982
      }
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3983
    }
a27fa687eca8 8028275: Metaspace ShrinkGrowTest causes fatal error if run with JFR
coleenp
parents: 22532
diff changeset
  3984
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3985
    if (can_try_again) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3986
      // reset safe_to_recreate_vm to 1 so that retrial would be possible
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3987
      safe_to_recreate_vm = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3988
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3989
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3990
    // Creation failed. We must reset vm_created
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3991
    *vm = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3992
    *(JNIEnv**)penv = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3993
    // reset vm_created last to avoid race condition. Use OrderAccess to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3994
    // control both compiler and architectural-based reordering.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3995
    OrderAccess::release_store(&vm_created, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3996
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3997
33600
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  3998
  // Flush stdout and stderr before exit.
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  3999
  fflush(stdout);
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  4000
  fflush(stderr);
922600753f71 8139801: Error message from validation check has wrong order on Windows
sangheki
parents: 33576
diff changeset
  4001
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4002
  return result;
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4003
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4004
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4005
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4006
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_CreateJavaVM(JavaVM **vm, void **penv, void *args) {
46955
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4007
  jint result = JNI_ERR;
30143
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4008
  // On Windows, let CreateJavaVM run with SEH protection
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4009
#ifdef _WIN32
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4010
  __try {
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4011
#endif
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4012
    result = JNI_CreateJavaVM_inner(vm, penv, args);
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4013
#ifdef _WIN32
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4014
  } __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4015
    // Nothing to do.
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4016
  }
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4017
#endif
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4018
  return result;
7e99f2b4bae5 8074860: Structured Exception Catcher missing around CreateJavaVM on Windows
stuefe
parents: 29081
diff changeset
  4019
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4020
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4021
_JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetCreatedJavaVMs(JavaVM **vm_buf, jsize bufLen, jsize *numVMs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4022
  // See bug 4367188, the wrapper can sometimes cause VM crashes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4023
  // JNIWrapper("GetCreatedJavaVMs");
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  4024
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4025
  HOTSPOT_JNI_GETCREATEDJAVAVMS_ENTRY((void **) vm_buf, bufLen, (uintptr_t *) numVMs);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22795
diff changeset
  4026
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  4027
  if (vm_created == 1) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4028
    if (numVMs != NULL) *numVMs = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4029
    if (bufLen > 0)     *vm_buf = (JavaVM *)(&main_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4030
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4031
    if (numVMs != NULL) *numVMs = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4032
  }
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4033
  HOTSPOT_JNI_GETCREATEDJAVAVMS_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4034
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4035
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4036
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4037
extern "C" {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4038
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4039
DT_RETURN_MARK_DECL(DestroyJavaVM, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4040
                    , HOTSPOT_JNI_DESTROYJAVAVM_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4041
46955
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4042
static jint JNICALL jni_DestroyJavaVM_inner(JavaVM *vm) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4043
  HOTSPOT_JNI_DESTROYJAVAVM_ENTRY(vm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4044
  jint res = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4045
  DT_RETURN_MARK(DestroyJavaVM, jint, (const jint&)res);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4046
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  4047
  if (vm_created == 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4048
    res = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4049
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4050
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4052
  JNIWrapper("DestroyJavaVM");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4053
  JNIEnv *env;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4054
  JavaVMAttachArgs destroyargs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4055
  destroyargs.version = CurrentVersion;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4056
  destroyargs.name = (char *)"DestroyJavaVM";
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4057
  destroyargs.group = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4058
  res = vm->AttachCurrentThread((void **)&env, (void *)&destroyargs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4059
  if (res != JNI_OK) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4060
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4061
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4063
  // Since this is not a JVM_ENTRY we have to set the thread state manually before entering.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4064
  JavaThread* thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4065
  ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4066
  if (Threads::destroy_vm()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4067
    // Should not change thread state, VM is gone
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  4068
    vm_created = 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4069
    res = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4070
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4071
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4072
    ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4073
    res = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4074
    return res;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4075
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4076
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4077
46955
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4078
jint JNICALL jni_DestroyJavaVM(JavaVM *vm) {
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4079
  jint result = JNI_ERR;
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4080
  // On Windows, we need SEH protection
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4081
#ifdef _WIN32
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4082
  __try {
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4083
#endif
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4084
    result = jni_DestroyJavaVM_inner(vm);
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4085
#ifdef _WIN32
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4086
  } __except(topLevelExceptionFilter((_EXCEPTION_POINTERS*)_exception_info())) {
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4087
    // Nothing to do.
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4088
  }
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4089
#endif
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4090
  return result;
c5a455ec08c0 8186199: [windows] JNI_DestroyJavaVM not covered by SEH
stuefe
parents: 46589
diff changeset
  4091
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4092
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4093
static jint attach_current_thread(JavaVM *vm, void **penv, void *_args, bool daemon) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4094
  JavaVMAttachArgs *args = (JavaVMAttachArgs *) _args;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4095
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4096
  // Check below commented out from JDK1.2fcs as well
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4097
  /*
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4098
  if (args && (args->version != JNI_VERSION_1_1 || args->version != JNI_VERSION_1_2)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4099
    return JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4100
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4101
  */
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4102
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4103
  Thread* t = Thread::current_or_null();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4104
  if (t != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4105
    // If the thread has been attached this operation is a no-op
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4106
    *(JNIEnv**)penv = ((JavaThread*) t)->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4107
    return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4108
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4109
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4110
  // Create a thread and mark it as attaching so it will be skipped by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4111
  // ThreadsListEnumerator - see CR 6404306
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4112
  JavaThread* thread = new JavaThread(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4113
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4114
  // Set correct safepoint info. The thread is going to call into Java when
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4115
  // initializing the Java level thread object. Hence, the correct state must
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4116
  // be set in order for the Safepoint code to deal with it correctly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4117
  thread->set_thread_state(_thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4118
  thread->record_stack_base_and_size();
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4119
  thread->initialize_thread_current();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4120
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4121
  if (!os::create_attached_thread(thread)) {
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47998
diff changeset
  4122
    thread->smr_delete();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4123
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4124
  }
5041
5bce37d77dde 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 4571
diff changeset
  4125
  // Enable stack overflow checks
5bce37d77dde 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 4571
diff changeset
  4126
  thread->create_stack_guard_pages();
5bce37d77dde 6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents: 4571
diff changeset
  4127
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4128
  thread->initialize_tlab();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4129
6176
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
  4130
  thread->cache_global_variables();
4d9030fe341f 6953477: Increase portability and flexibility of building Hotspot
bobv
parents: 5547
diff changeset
  4131
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4132
  // Crucial that we do not have a safepoint check for this thread, since it has
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4133
  // not been added to the Thread list yet.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4134
  { Threads_lock->lock_without_safepoint_check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4135
    // This must be inside this lock in order to get FullGCALot to work properly, i.e., to
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4136
    // avoid this thread trying to do a GC before it is added to the thread-list
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4137
    thread->set_active_handles(JNIHandleBlock::allocate_block());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4138
    Threads::add(thread, daemon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4139
    Threads_lock->unlock();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4140
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4141
  // Create thread group and name info from attach arguments
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4142
  oop group = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4143
  char* thread_name = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4144
  if (args != NULL && Threads::is_supported_jni_version(args->version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4145
    group = JNIHandles::resolve(args->group);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4146
    thread_name = args->name; // may be NULL
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4148
  if (group == NULL) group = Universe::main_thread_group();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4150
  // Create Java level thread object and attach it to this thread
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4151
  bool attach_failed = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4152
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4153
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4154
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4155
    Handle thread_group(THREAD, group);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4156
    thread->allocate_threadObj(thread_group, thread_name, daemon, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4157
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4158
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4159
      // cleanup outside the handle mark.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4160
      attach_failed = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4161
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4162
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4163
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4164
  if (attach_failed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4165
    // Added missing cleanup
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4166
    thread->cleanup_failed_attach_current_thread();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4167
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4168
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4169
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4170
  // mark the thread as no longer attaching
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4171
  // this uses a fence to push the change through so we don't have
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4172
  // to regrab the threads_lock
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4173
  thread->set_done_attaching_via_jni();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4174
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4175
  // Set java thread status.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4176
  java_lang_Thread::set_thread_status(thread->threadObj(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4177
              java_lang_Thread::RUNNABLE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4178
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4179
  // Notify the debugger
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4180
  if (JvmtiExport::should_post_thread_life()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4181
    JvmtiExport::post_thread_start(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4182
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4183
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4184
  EventThreadStart event;
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4185
  if (event.should_commit()) {
36384
b0b41336a9a8 8143226: Minor updates to Event Based tracing
mgronlun
parents: 36183
diff changeset
  4186
    event.set_thread(THREAD_TRACE_ID(thread));
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4187
    event.commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17631
diff changeset
  4188
  }
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  4189
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4190
  *(JNIEnv**)penv = thread->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4191
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4192
  // Now leaving the VM, so change thread_state. This is normally automatically taken care
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4193
  // of in the JVM_ENTRY. But in this situation we have to do it manually. Notice, that by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4194
  // using ThreadStateTransition::transition, we do a callback to the safepoint code if
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4195
  // needed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4196
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4197
  ThreadStateTransition::transition_and_fence(thread, _thread_in_vm, _thread_in_native);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4198
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4199
  // Perform any platform dependent FPU setup
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4200
  os::setup_fpu();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4201
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4202
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4203
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4204
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4205
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4206
jint JNICALL jni_AttachCurrentThread(JavaVM *vm, void **penv, void *_args) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4207
  HOTSPOT_JNI_ATTACHCURRENTTHREAD_ENTRY(vm, penv, _args);
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  4208
  if (vm_created == 0) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4209
  HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4210
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4211
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4212
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4213
  JNIWrapper("AttachCurrentThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4214
  jint ret = attach_current_thread(vm, penv, _args, false);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4215
  HOTSPOT_JNI_ATTACHCURRENTTHREAD_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4216
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4217
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4218
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4219
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4220
jint JNICALL jni_DetachCurrentThread(JavaVM *vm)  {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4221
  HOTSPOT_JNI_DETACHCURRENTTHREAD_ENTRY(vm);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4222
  VM_Exit::block_if_vm_exited();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4223
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4224
  JNIWrapper("DetachCurrentThread");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4225
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4226
  // If the thread has already been detached the operation is a no-op
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4227
  if (Thread::current_or_null() == NULL) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4228
  HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4229
    return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4230
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4231
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4232
  JavaThread* thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4233
  if (thread->has_last_Java_frame()) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4234
  HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN((uint32_t) JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4235
    // Can't detach a thread that's running java, that can't work.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4236
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4237
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4238
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4239
  // Safepoint support. Have to do call-back to safepoint code, if in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4240
  // middel of a safepoint operation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4241
  ThreadStateTransition::transition_from_native(thread, _thread_in_vm);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4242
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4243
  // XXX: Note that JavaThread::exit() call below removes the guards on the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4244
  // stack pages set up via enable_stack_{red,yellow}_zone() calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4245
  // above in jni_AttachCurrentThread. Unfortunately, while the setting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4246
  // of the guards is visible in jni_AttachCurrentThread above,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4247
  // the removal of the guards is buried below in JavaThread::exit()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4248
  // here. The abstraction should be more symmetrically either exposed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4249
  // or hidden (e.g. it could probably be hidden in the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4250
  // (platform-dependent) methods where we do alternate stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4251
  // maintenance work?)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4252
  thread->exit(false, JavaThread::jni_detach);
48105
8d15b1369c7a 8167108: inconsistent handling of SR_lock can lead to crashes
dcubed
parents: 47998
diff changeset
  4253
  thread->smr_delete();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4254
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4255
  HOTSPOT_JNI_DETACHCURRENTTHREAD_RETURN(JNI_OK);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4256
  return JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4257
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4258
10739
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4259
DT_RETURN_MARK_DECL(GetEnv, jint
91935236600e 7098194: integrate macosx-port changes
dcubed
parents: 10565
diff changeset
  4260
                    , HOTSPOT_JNI_GETENV_RETURN(_ret_ref));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4261
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4262
jint JNICALL jni_GetEnv(JavaVM *vm, void **penv, jint version) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4263
  HOTSPOT_JNI_GETENV_ENTRY(vm, penv, version);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4264
  jint ret = JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4265
  DT_RETURN_MARK(GetEnv, jint, (const jint&)ret);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4266
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  4267
  if (vm_created == 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4268
    *penv = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4269
    ret = JNI_EDETACHED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4270
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4271
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4272
11480
1bf714e8adb4 7115199: Add event tracing hooks and Java Flight Recorder infrastructure
phh
parents: 11247
diff changeset
  4273
  if (JniExportedInterface::GetExportedInterface(vm, penv, version, &ret)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4274
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4275
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4276
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4277
#ifndef JVMPI_VERSION_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4278
// need these in order to be polite about older agents
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4279
#define JVMPI_VERSION_1   ((jint)0x10000001)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4280
#define JVMPI_VERSION_1_1 ((jint)0x10000002)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4281
#define JVMPI_VERSION_1_2 ((jint)0x10000003)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4282
#endif // !JVMPI_VERSION_1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4283
34633
2a6c7c7b30a7 8132510: Replace ThreadLocalStorage with compiler/language-based thread-local variables
dholmes
parents: 34317
diff changeset
  4284
  Thread* thread = Thread::current_or_null();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4285
  if (thread != NULL && thread->is_Java_thread()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4286
    if (Threads::is_supported_jni_version_including_1_1(version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4287
      *(JNIEnv**)penv = ((JavaThread*) thread)->jni_environment();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4288
      ret = JNI_OK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4289
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4290
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4291
    } else if (version == JVMPI_VERSION_1 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4292
               version == JVMPI_VERSION_1_1 ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4293
               version == JVMPI_VERSION_1_2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4294
      tty->print_cr("ERROR: JVMPI, an experimental interface, is no longer supported.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4295
      tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4296
      ret = JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4297
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4298
    } else if (JvmtiExport::is_jvmdi_version(version)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4299
      tty->print_cr("FATAL ERROR: JVMDI is no longer supported.");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4300
      tty->print_cr("Please use the supported interface: the JVM Tool Interface (JVM TI).");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4301
      ret = JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4302
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4303
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4304
      *penv = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4305
      ret = JNI_EVERSION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4306
      return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4307
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4308
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4309
    *penv = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4310
    ret = JNI_EDETACHED;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4311
    return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4312
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4313
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4314
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4315
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4316
jint JNICALL jni_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *_args) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4317
  HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_ENTRY(vm, penv, _args);
47765
b7c7428eaab9 8189610: Reconcile jvm.h and all jvm_md.h between java.base and hotspot
coleenp
parents: 47662
diff changeset
  4318
  if (vm_created == 0) {
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4319
  HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN((uint32_t) JNI_ERR);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4320
    return JNI_ERR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4322
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4323
  JNIWrapper("AttachCurrentThreadAsDaemon");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4324
  jint ret = attach_current_thread(vm, penv, _args, true);
22520
b9e88eed82d7 8030812: Change the solaris DTrace implementation to use USDT2 instead of USDT1
sla
parents: 22190
diff changeset
  4325
  HOTSPOT_JNI_ATTACHCURRENTTHREADASDAEMON_RETURN(ret);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4326
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4327
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4328
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4329
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4330
} // End extern "C"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4331
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4332
const struct JNIInvokeInterface_ jni_InvokeInterface = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4333
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4334
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4335
    NULL,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4336
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4337
    jni_DestroyJavaVM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4338
    jni_AttachCurrentThread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4339
    jni_DetachCurrentThread,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4340
    jni_GetEnv,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4341
    jni_AttachCurrentThreadAsDaemon
489c9b5090e2 Initial load
duke
parents:
diff changeset
  4342
};