hotspot/src/share/vm/prims/unsafe.cpp
author coleenp
Thu, 19 Jun 2014 14:49:33 -0400
changeset 25326 85b2f2e63e3e
parent 25057 f38210f84f8c
child 25354 f6762819b488
permissions -rw-r--r--
6642881: Improve performance of Class.getClassLoader() Summary: Add classLoader to java/lang/Class instance for fast access Reviewed-by: alanb, lfoltan, rriggs, vlivanov, twisti, jfranck
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24351
diff changeset
     2
 * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5089
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5089
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5089
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "classfile/vmSymbols.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14832
diff changeset
    27
#include "utilities/macros.hpp"
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14832
diff changeset
    28
#if INCLUDE_ALL_GCS
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
    29
#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14832
diff changeset
    30
#endif // INCLUDE_ALL_GCS
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "prims/jni.h"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "prims/jvm.h"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "runtime/globals.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "runtime/interfaceSupport.hpp"
24487
71ff0bd674eb 8042737: Introduce umbrella header prefetch.inline.hpp
goetz
parents: 24424
diff changeset
    36
#include "runtime/prefetch.inline.hpp"
24351
61b33cc6d3cf 8042195: Introduce umbrella header orderAccess.inline.hpp.
goetz
parents: 24322
diff changeset
    37
#include "runtime/orderAccess.inline.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    38
#include "runtime/reflection.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    39
#include "runtime/synchronizer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    40
#include "services/threadService.hpp"
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17881
diff changeset
    41
#include "trace/tracing.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    42
#include "utilities/copy.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    43
#include "utilities/dtrace.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    44
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24351
diff changeset
    45
PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24351
diff changeset
    46
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
 *      Implementation of class sun.misc.Unsafe
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
5089
0cce506a0158 6935224: Adding new DTrace probes to work with Palantir
fparain
parents: 3262
diff changeset
    51
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
#define MAX_OBJECT_SIZE \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  ( arrayOopDesc::header_size(T_DOUBLE) * HeapWordSize \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
    + ((julong)max_jint * sizeof(double)) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
#define UNSAFE_ENTRY(result_type, header) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  JVM_ENTRY(result_type, header)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
// Can't use UNSAFE_LEAF because it has the signature of a straight
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// call into the runtime (just like JVM_LEAF, funny that) but it's
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
// called like a Java Native and thus the wrapper built for it passes
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
// arguments like a JNI call.  It expects those arguments to be popped
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// from the stack on Intel like all good JNI args are, and adjusts the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
// stack according.  Since the JVM_LEAF call expects no extra
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
// arguments the stack isn't popped in the C code, is pushed by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
// wrapper and we get sick.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
//#define UNSAFE_LEAF(result_type, header) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
//  JVM_LEAF(result_type, header)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
#define UNSAFE_END JVM_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
#define UnsafeWrapper(arg) /*nothing, for the present*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
inline void* addr_from_java(jlong addr) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  // This assert fails in a variety of ways on 32-bit systems.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
  // It is impossible to predict whether native code that converts
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // pointers to longs will sign-extend or zero-extend the addresses.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  //assert(addr == (uintptr_t)addr, "must not be odd high bits");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  return (void*)(uintptr_t)addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
inline jlong addr_to_java(void* p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  assert(p == (void*)(uintptr_t)p, "must not be odd high bits");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  return (uintptr_t)p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
// Note: The VM's obj_field and related accessors use byte-scaled
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
// ("unscaled") offsets, just as the unsafe methods do.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
// However, the method Unsafe.fieldOffset explicitly declines to
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
// guarantee this.  The field offset values manipulated by the Java user
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
// through the Unsafe API are opaque cookies that just happen to be byte
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
// offsets.  We represent this state of affairs by passing the cookies
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
// through conversion functions when going between the VM and the Unsafe API.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
// The conversion functions just happen to be no-ops at present.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
inline jlong field_offset_to_byte_offset(jlong field_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  return field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
inline jlong field_offset_from_byte_offset(jlong byte_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  return byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
inline jint invocation_key_from_method_slot(jint slot) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  return slot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
inline jint invocation_key_to_method_slot(jint key) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  return key;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
inline void* index_oop_from_field_offset_long(oop p, jlong field_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  jlong byte_offset = field_offset_to_byte_offset(field_offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  if (p != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    assert(byte_offset >= 0 && byte_offset <= (jlong)MAX_OBJECT_SIZE, "sane offset");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    if (byte_offset == (jint)byte_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
      void* ptr_plus_disp = (address)p + byte_offset;
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   123
      assert((void*)p->obj_field_addr<oop>((jint)byte_offset) == ptr_plus_disp,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
             "raw [ptr+disp] must be consistent with oop::field_base");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
    }
14127
16ba0a8dfde2 8001071: Add simple range check into VM implemenation of Unsafe access methods
kvn
parents: 13952
diff changeset
   126
    jlong p_size = HeapWordSize * (jlong)(p->size());
16ba0a8dfde2 8001071: Add simple range check into VM implemenation of Unsafe access methods
kvn
parents: 13952
diff changeset
   127
    assert(byte_offset < p_size, err_msg("Unsafe access: offset " INT64_FORMAT " > object's size " INT64_FORMAT, byte_offset, p_size));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  if (sizeof(char*) == sizeof(jint))    // (this constant folds!)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
    return (address)p + (jint) byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    return (address)p +        byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
// Externally callable versions:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
// (Use these in compiler intrinsics which emulate unsafe primitives.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
jlong Unsafe_field_offset_to_byte_offset(jlong field_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  return field_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
jlong Unsafe_field_offset_from_byte_offset(jlong byte_offset) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  return byte_offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
jint Unsafe_invocation_key_from_method_slot(jint slot) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  return invocation_key_from_method_slot(slot);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
jint Unsafe_invocation_key_to_method_slot(jint key) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  return invocation_key_to_method_slot(key);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
///// Data in the Java heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
#define GET_FIELD(obj, offset, type_name, v) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  oop p = JNIHandles::resolve(obj); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  type_name v = *(type_name*)index_oop_from_field_offset_long(p, offset)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
#define SET_FIELD(obj, offset, type_name, x) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  oop p = JNIHandles::resolve(obj); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  *(type_name*)index_oop_from_field_offset_long(p, offset) = x
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
#define GET_FIELD_VOLATILE(obj, offset, type_name, v) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  oop p = JNIHandles::resolve(obj); \
22868
7f6eb436873b 8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents: 20282
diff changeset
   164
  if (support_IRIW_for_not_multiple_copy_atomic_cpu) { \
7f6eb436873b 8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents: 20282
diff changeset
   165
    OrderAccess::fence(); \
7f6eb436873b 8029101: PPC64 (part 211): ordering of Independent Reads of Independent Writes
goetz
parents: 20282
diff changeset
   166
  } \
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   167
  volatile type_name v = OrderAccess::load_acquire((volatile type_name*)index_oop_from_field_offset_long(p, offset));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
#define SET_FIELD_VOLATILE(obj, offset, type_name, x) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  oop p = JNIHandles::resolve(obj); \
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   171
  OrderAccess::release_store_fence((volatile type_name*)index_oop_from_field_offset_long(p, offset), x);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   173
// Macros for oops that check UseCompressedOops
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   174
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   175
#define GET_OOP_FIELD(obj, offset, v) \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   176
  oop p = JNIHandles::resolve(obj);   \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   177
  oop v;                              \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   178
  if (UseCompressedOops) {            \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   179
    narrowOop n = *(narrowOop*)index_oop_from_field_offset_long(p, offset); \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   180
    v = oopDesc::decode_heap_oop(n);                                \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   181
  } else {                            \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   182
    v = *(oop*)index_oop_from_field_offset_long(p, offset);                 \
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   183
  }
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   184
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   185
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
// Get/SetObject must be special-cased, since it works with handles.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
25057
f38210f84f8c 8031819: Remove legacy jdk checks and code
hseigel
parents: 24487
diff changeset
   188
// These functions allow a null base pointer with an arbitrary address.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
// But if the base pointer is non-null, the offset should make some sense.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
// That is, it should be in the range [0, MAX_OBJECT_SIZE].
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  UnsafeWrapper("Unsafe_GetObject");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   193
  GET_OOP_FIELD(obj, offset, v)
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   194
  jobject ret = JNIHandles::make_local(env, v);
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14832
diff changeset
   195
#if INCLUDE_ALL_GCS
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   196
  // We could be accessing the referent field in a reference
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   197
  // object. If G1 is enabled then we need to register non-null
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   198
  // referent with the SATB barrier.
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   199
  if (UseG1GC) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   200
    bool needs_barrier = false;
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   201
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   202
    if (ret != NULL) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   203
      if (offset == java_lang_ref_Reference::referent_offset && obj != NULL) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   204
        oop o = JNIHandles::resolve(obj);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   205
        Klass* k = o->klass();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   206
        if (InstanceKlass::cast(k)->reference_type() != REF_NONE) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   207
          assert(InstanceKlass::cast(k)->is_subclass_of(SystemDictionary::Reference_klass()), "sanity");
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   208
          needs_barrier = true;
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   209
        }
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   210
      }
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   211
    }
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   212
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   213
    if (needs_barrier) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   214
      oop referent = JNIHandles::resolve(ret);
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   215
      G1SATBCardTableModRefBS::enqueue(referent);
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   216
    }
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   217
  }
15482
470d0b0c09f1 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS
jprovino
parents: 14832
diff changeset
   218
#endif // INCLUDE_ALL_GCS
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 8725
diff changeset
   219
  return ret;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
UNSAFE_ENTRY(void, Unsafe_SetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  UnsafeWrapper("Unsafe_SetObject");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  oop x = JNIHandles::resolve(x_h);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  oop p = JNIHandles::resolve(obj);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   226
  if (UseCompressedOops) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   227
    oop_store((narrowOop*)index_oop_from_field_offset_long(p, offset), x);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   228
  } else {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   229
    oop_store((oop*)index_oop_from_field_offset_long(p, offset), x);
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   230
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
UNSAFE_ENTRY(jobject, Unsafe_GetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  UnsafeWrapper("Unsafe_GetObjectVolatile");
13293
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   235
  oop p = JNIHandles::resolve(obj);
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   236
  void* addr = index_oop_from_field_offset_long(p, offset);
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   237
  volatile oop v;
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   238
  if (UseCompressedOops) {
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   239
    volatile narrowOop n = *(volatile narrowOop*) addr;
20282
7f9cbdf89af2 7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents: 18025
diff changeset
   240
    (void)const_cast<oop&>(v = oopDesc::decode_heap_oop(n));
13293
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   241
  } else {
20282
7f9cbdf89af2 7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents: 18025
diff changeset
   242
    (void)const_cast<oop&>(v = *(volatile oop*) addr);
13293
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   243
  }
c2b4f191c489 7087357: JSR 292: remove obsolete code after 7085860
twisti
parents: 10967
diff changeset
   244
  OrderAccess::acquire();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  return JNIHandles::make_local(env, v);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
UNSAFE_ENTRY(void, Unsafe_SetObjectVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  UnsafeWrapper("Unsafe_SetObjectVolatile");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  oop x = JNIHandles::resolve(x_h);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  oop p = JNIHandles::resolve(obj);
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   252
  void* addr = index_oop_from_field_offset_long(p, offset);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   253
  OrderAccess::release();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   254
  if (UseCompressedOops) {
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   255
    oop_store((narrowOop*)addr, x);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   256
  } else {
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   257
    oop_store((oop*)addr, x);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   258
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
  OrderAccess::fence();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
17316
c1f00a6ecf59 8013633: Cleanup platform ifdefs in unsafe.cpp
bpittore
parents: 16617
diff changeset
   262
#ifndef SUPPORTS_NATIVE_CX8
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   263
// Keep old code for platforms which may not have atomic jlong (8 bytes) instructions
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   264
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
// Volatile long versions must use locks if !VM_Version::supports_cx8().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
// support_cx8 is a surrogate for 'supports atomic long memory ops'.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
UNSAFE_ENTRY(jlong, Unsafe_GetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  UnsafeWrapper("Unsafe_GetLongVolatile");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
    if (VM_Version::supports_cx8()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
      GET_FIELD_VOLATILE(obj, offset, jlong, v);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
      return v;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
      Handle p (THREAD, JNIHandles::resolve(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
      jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
      ObjectLocker ol(p, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
      jlong value = *addr;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
      return value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
UNSAFE_ENTRY(void, Unsafe_SetLongVolatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  UnsafeWrapper("Unsafe_SetLongVolatile");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    if (VM_Version::supports_cx8()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      SET_FIELD_VOLATILE(obj, offset, jlong, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
      Handle p (THREAD, JNIHandles::resolve(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
      jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
      ObjectLocker ol(p, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
      *addr = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
17316
c1f00a6ecf59 8013633: Cleanup platform ifdefs in unsafe.cpp
bpittore
parents: 16617
diff changeset
   300
#endif // not SUPPORTS_NATIVE_CX8
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
#define DEFINE_GETSETOOP(jboolean, Boolean) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  UnsafeWrapper("Unsafe_Get"#Boolean); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  if (obj == NULL)  THROW_0(vmSymbols::java_lang_NullPointerException()); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  GET_FIELD(obj, offset, jboolean, v); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  return v; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
UNSAFE_ENTRY(void, Unsafe_Set##Boolean##140(JNIEnv *env, jobject unsafe, jobject obj, jint offset, jboolean x)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  UnsafeWrapper("Unsafe_Set"#Boolean); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  if (obj == NULL)  THROW(vmSymbols::java_lang_NullPointerException()); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  SET_FIELD(obj, offset, jboolean, x); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  UnsafeWrapper("Unsafe_Get"#Boolean); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  GET_FIELD(obj, offset, jboolean, v); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  return v; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
UNSAFE_ENTRY(void, Unsafe_Set##Boolean(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  UnsafeWrapper("Unsafe_Set"#Boolean); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  SET_FIELD(obj, offset, jboolean, x); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
// END DEFINE_GETSETOOP.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   330
DEFINE_GETSETOOP(jboolean, Boolean)
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   331
DEFINE_GETSETOOP(jbyte, Byte)
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   332
DEFINE_GETSETOOP(jshort, Short);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   333
DEFINE_GETSETOOP(jchar, Char);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   334
DEFINE_GETSETOOP(jint, Int);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   335
DEFINE_GETSETOOP(jlong, Long);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   336
DEFINE_GETSETOOP(jfloat, Float);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   337
DEFINE_GETSETOOP(jdouble, Double);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   338
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   339
#undef DEFINE_GETSETOOP
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
#define DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
UNSAFE_ENTRY(jboolean, Unsafe_Get##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  UnsafeWrapper("Unsafe_Get"#Boolean); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  GET_FIELD_VOLATILE(obj, offset, jboolean, v); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  return v; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
UNSAFE_ENTRY(void, Unsafe_Set##Boolean##Volatile(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jboolean x)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  UnsafeWrapper("Unsafe_Set"#Boolean); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  SET_FIELD_VOLATILE(obj, offset, jboolean, x); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
// END DEFINE_GETSETOOP_VOLATILE.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
DEFINE_GETSETOOP_VOLATILE(jboolean, Boolean)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
DEFINE_GETSETOOP_VOLATILE(jbyte, Byte)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
DEFINE_GETSETOOP_VOLATILE(jshort, Short);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
DEFINE_GETSETOOP_VOLATILE(jchar, Char);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
DEFINE_GETSETOOP_VOLATILE(jint, Int);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
DEFINE_GETSETOOP_VOLATILE(jfloat, Float);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
DEFINE_GETSETOOP_VOLATILE(jdouble, Double);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
17316
c1f00a6ecf59 8013633: Cleanup platform ifdefs in unsafe.cpp
bpittore
parents: 16617
diff changeset
   364
#ifdef SUPPORTS_NATIVE_CX8
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   365
DEFINE_GETSETOOP_VOLATILE(jlong, Long);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   366
#endif
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   367
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   368
#undef DEFINE_GETSETOOP_VOLATILE
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
// The non-intrinsified versions of setOrdered just use setVolatile
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   372
UNSAFE_ENTRY(void, Unsafe_SetOrderedInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint x))
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   373
  UnsafeWrapper("Unsafe_SetOrderedInt");
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   374
  SET_FIELD_VOLATILE(obj, offset, jint, x);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
UNSAFE_ENTRY(void, Unsafe_SetOrderedObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject x_h))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  UnsafeWrapper("Unsafe_SetOrderedObject");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  oop x = JNIHandles::resolve(x_h);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  oop p = JNIHandles::resolve(obj);
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   381
  void* addr = index_oop_from_field_offset_long(p, offset);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   382
  OrderAccess::release();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   383
  if (UseCompressedOops) {
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   384
    oop_store((narrowOop*)addr, x);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   385
  } else {
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   386
    oop_store((oop*)addr, x);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   387
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  OrderAccess::fence();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
UNSAFE_ENTRY(void, Unsafe_SetOrderedLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  UnsafeWrapper("Unsafe_SetOrderedLong");
17316
c1f00a6ecf59 8013633: Cleanup platform ifdefs in unsafe.cpp
bpittore
parents: 16617
diff changeset
   393
#ifdef SUPPORTS_NATIVE_CX8
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   394
  SET_FIELD_VOLATILE(obj, offset, jlong, x);
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   395
#else
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   396
  // Keep old code for platforms which may not have atomic long (8 bytes) instructions
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
    if (VM_Version::supports_cx8()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
      SET_FIELD_VOLATILE(obj, offset, jlong, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
      Handle p (THREAD, JNIHandles::resolve(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
      jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
      ObjectLocker ol(p, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
      *addr = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  }
7885
c02b05ba16a1 7009756: volatile variables could be broken throw reflection API
kvn
parents: 7397
diff changeset
   408
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
14832
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   411
UNSAFE_ENTRY(void, Unsafe_LoadFence(JNIEnv *env, jobject unsafe))
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   412
  UnsafeWrapper("Unsafe_LoadFence");
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   413
  OrderAccess::acquire();
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   414
UNSAFE_END
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   415
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   416
UNSAFE_ENTRY(void, Unsafe_StoreFence(JNIEnv *env, jobject unsafe))
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   417
  UnsafeWrapper("Unsafe_StoreFence");
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   418
  OrderAccess::release();
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   419
UNSAFE_END
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   420
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   421
UNSAFE_ENTRY(void, Unsafe_FullFence(JNIEnv *env, jobject unsafe))
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   422
  UnsafeWrapper("Unsafe_FullFence");
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   423
  OrderAccess::fence();
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   424
UNSAFE_END
61b025224ac9 8004318: JEP-171: Support Unsafe fences intrinsics
kvn
parents: 14588
diff changeset
   425
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
////// Data in the C heap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
// Note:  These do not throw NullPointerException for bad pointers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
// They just crash.  Only a oop base pointer can generate a NullPointerException.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
#define DEFINE_GETSETNATIVE(java_type, Type, native_type) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
UNSAFE_ENTRY(java_type, Unsafe_GetNative##Type(JNIEnv *env, jobject unsafe, jlong addr)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  UnsafeWrapper("Unsafe_GetNative"#Type); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
  void* p = addr_from_java(addr); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  JavaThread* t = JavaThread::current(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
  t->set_doing_unsafe_access(true); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  java_type x = *(volatile native_type*)p; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
  t->set_doing_unsafe_access(false); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  return x; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
UNSAFE_ENTRY(void, Unsafe_SetNative##Type(JNIEnv *env, jobject unsafe, jlong addr, java_type x)) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  UnsafeWrapper("Unsafe_SetNative"#Type); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  JavaThread* t = JavaThread::current(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  t->set_doing_unsafe_access(true); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  void* p = addr_from_java(addr); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  *(volatile native_type*)p = x; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  t->set_doing_unsafe_access(false); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
UNSAFE_END \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
 \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
// END DEFINE_GETSETNATIVE.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
DEFINE_GETSETNATIVE(jbyte, Byte, signed char)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
DEFINE_GETSETNATIVE(jshort, Short, signed short);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
DEFINE_GETSETNATIVE(jchar, Char, unsigned short);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
DEFINE_GETSETNATIVE(jint, Int, jint);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
// no long -- handled specially
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
DEFINE_GETSETNATIVE(jfloat, Float, float);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
DEFINE_GETSETNATIVE(jdouble, Double, double);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
#undef DEFINE_GETSETNATIVE
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
UNSAFE_ENTRY(jlong, Unsafe_GetNativeLong(JNIEnv *env, jobject unsafe, jlong addr))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  UnsafeWrapper("Unsafe_GetNativeLong");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  JavaThread* t = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  // We do it this way to avoid problems with access to heap using 64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  // bit loads, as jlong in heap could be not 64-bit aligned, and on
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  // some CPUs (SPARC) it leads to SIGBUS.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  t->set_doing_unsafe_access(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  void* p = addr_from_java(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  jlong x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  if (((intptr_t)p & 7) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
    // jlong is aligned, do a volatile access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
    x = *(volatile jlong*)p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    jlong_accessor acc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
    acc.words[0] = ((volatile jint*)p)[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    acc.words[1] = ((volatile jint*)p)[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    x = acc.long_value;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  t->set_doing_unsafe_access(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  return x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
UNSAFE_ENTRY(void, Unsafe_SetNativeLong(JNIEnv *env, jobject unsafe, jlong addr, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  UnsafeWrapper("Unsafe_SetNativeLong");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  JavaThread* t = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  // see comment for Unsafe_GetNativeLong
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  t->set_doing_unsafe_access(true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  void* p = addr_from_java(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  if (((intptr_t)p & 7) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
    // jlong is aligned, do a volatile access
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
    *(volatile jlong*)p = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    jlong_accessor acc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    acc.long_value = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    ((volatile jint*)p)[0] = acc.words[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
    ((volatile jint*)p)[1] = acc.words[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  t->set_doing_unsafe_access(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
UNSAFE_ENTRY(jlong, Unsafe_GetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  UnsafeWrapper("Unsafe_GetNativeAddress");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  void* p = addr_from_java(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  return addr_to_java(*(void**)p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
UNSAFE_ENTRY(void, Unsafe_SetNativeAddress(JNIEnv *env, jobject unsafe, jlong addr, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  UnsafeWrapper("Unsafe_SetNativeAddress");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  void* p = addr_from_java(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  *(void**)p = addr_from_java(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
////// Allocation requests
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
UNSAFE_ENTRY(jobject, Unsafe_AllocateInstance(JNIEnv *env, jobject unsafe, jclass cls))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  UnsafeWrapper("Unsafe_AllocateInstance");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
    ThreadToNativeFromVM ttnfv(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
    return env->AllocObject(cls);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
UNSAFE_ENTRY(jlong, Unsafe_AllocateMemory(JNIEnv *env, jobject unsafe, jlong size))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  UnsafeWrapper("Unsafe_AllocateMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  size_t sz = (size_t)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  if (sz != (julong)size || size < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    THROW_0(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  if (sz == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  sz = round_to(sz, HeapWordSize);
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
   538
  void* x = os::malloc(sz, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  if (x == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  //Copy::fill_to_words((HeapWord*)x, sz / HeapWordSize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  return addr_to_java(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
UNSAFE_ENTRY(jlong, Unsafe_ReallocateMemory(JNIEnv *env, jobject unsafe, jlong addr, jlong size))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  UnsafeWrapper("Unsafe_ReallocateMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  void* p = addr_from_java(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  size_t sz = (size_t)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  if (sz != (julong)size || size < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
    THROW_0(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  if (sz == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    os::free(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  sz = round_to(sz, HeapWordSize);
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
   558
  void* x = (p == NULL) ? os::malloc(sz, mtInternal) : os::realloc(p, sz, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  if (x == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  return addr_to_java(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
UNSAFE_ENTRY(void, Unsafe_FreeMemory(JNIEnv *env, jobject unsafe, jlong addr))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  UnsafeWrapper("Unsafe_FreeMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  void* p = addr_from_java(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  if (p == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  os::free(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
UNSAFE_ENTRY(void, Unsafe_SetMemory(JNIEnv *env, jobject unsafe, jlong addr, jlong size, jbyte value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  UnsafeWrapper("Unsafe_SetMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  size_t sz = (size_t)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  if (sz != (julong)size || size < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    THROW(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
  char* p = (char*) addr_from_java(addr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  Copy::fill_to_memory_atomic(p, sz, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
UNSAFE_ENTRY(void, Unsafe_SetMemory2(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong size, jbyte value))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
  UnsafeWrapper("Unsafe_SetMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  size_t sz = (size_t)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  if (sz != (julong)size || size < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    THROW(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  oop base = JNIHandles::resolve(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  void* p = index_oop_from_field_offset_long(base, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
  Copy::fill_to_memory_atomic(p, sz, value);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
UNSAFE_ENTRY(void, Unsafe_CopyMemory(JNIEnv *env, jobject unsafe, jlong srcAddr, jlong dstAddr, jlong size))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
  UnsafeWrapper("Unsafe_CopyMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  if (size == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
  size_t sz = (size_t)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  if (sz != (julong)size || size < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    THROW(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
  void* src = addr_from_java(srcAddr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
  void* dst = addr_from_java(dstAddr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  Copy::conjoint_memory_atomic(src, dst, sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
UNSAFE_ENTRY(void, Unsafe_CopyMemory2(JNIEnv *env, jobject unsafe, jobject srcObj, jlong srcOffset, jobject dstObj, jlong dstOffset, jlong size))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  UnsafeWrapper("Unsafe_CopyMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  if (size == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
  size_t sz = (size_t)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  if (sz != (julong)size || size < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
    THROW(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  oop srcp = JNIHandles::resolve(srcObj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  oop dstp = JNIHandles::resolve(dstObj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
  if (dstp != NULL && !dstp->is_typeArray()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
    // NYI:  This works only for non-oop arrays at present.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
    // Generalizing it would be reasonable, but requires card marking.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    // Also, autoboxing a Long from 0L in copyMemory(x,y, 0L,z, n) would be bad.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
    THROW(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
  void* src = index_oop_from_field_offset_long(srcp, srcOffset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
  void* dst = index_oop_from_field_offset_long(dstp, dstOffset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
  Copy::conjoint_memory_atomic(src, dst, sz);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
////// Random queries
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
// See comment at file start about UNSAFE_LEAF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
//UNSAFE_LEAF(jint, Unsafe_AddressSize())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
UNSAFE_ENTRY(jint, Unsafe_AddressSize(JNIEnv *env, jobject unsafe))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
  UnsafeWrapper("Unsafe_AddressSize");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
  return sizeof(void*);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
// See comment at file start about UNSAFE_LEAF
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
//UNSAFE_LEAF(jint, Unsafe_PageSize())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
UNSAFE_ENTRY(jint, Unsafe_PageSize(JNIEnv *env, jobject unsafe))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  UnsafeWrapper("Unsafe_PageSize");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  return os::vm_page_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
jint find_field_offset(jobject field, int must_be_static, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  if (field == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
    THROW_0(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
  oop reflected   = JNIHandles::resolve_non_null(field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
  oop mirror      = java_lang_reflect_Field::clazz(reflected);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   655
  Klass* k      = java_lang_Class::as_Klass(mirror);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  int slot        = java_lang_reflect_Field::slot(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  int modifiers   = java_lang_reflect_Field::modifiers(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  if (must_be_static >= 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
    int really_is_static = ((modifiers & JVM_ACC_STATIC) != 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
    if (must_be_static != really_is_static) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
      THROW_0(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   666
  int offset = InstanceKlass::cast(k)->field_offset(slot);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
  return field_offset_from_byte_offset(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
UNSAFE_ENTRY(jlong, Unsafe_ObjectFieldOffset(JNIEnv *env, jobject unsafe, jobject field))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  UnsafeWrapper("Unsafe_ObjectFieldOffset");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
  return find_field_offset(field, 0, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
UNSAFE_ENTRY(jlong, Unsafe_StaticFieldOffset(JNIEnv *env, jobject unsafe, jobject field))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  UnsafeWrapper("Unsafe_StaticFieldOffset");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  return find_field_offset(field, 1, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBaseFromField(JNIEnv *env, jobject unsafe, jobject field))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  UnsafeWrapper("Unsafe_StaticFieldBase");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
  // Note:  In this VM implementation, a field address is always a short
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  // offset from the base of a a klass metaobject.  Thus, the full dynamic
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
  // range of the return type is never used.  However, some implementations
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  // might put the static field inside an array shared by many classes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  // or even at a fixed address, in which case the address could be quite
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  // large.  In that last case, this function would return NULL, since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  // the address would operate alone, without any base pointer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  if (field == NULL)  THROW_0(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  oop reflected   = JNIHandles::resolve_non_null(field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
  oop mirror      = java_lang_reflect_Field::clazz(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
  int modifiers   = java_lang_reflect_Field::modifiers(reflected);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  if ((modifiers & JVM_ACC_STATIC) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
    THROW_0(vmSymbols::java_lang_IllegalArgumentException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8490
diff changeset
   700
  return JNIHandles::make_local(env, mirror);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
//@deprecated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
UNSAFE_ENTRY(jint, Unsafe_FieldOffset(JNIEnv *env, jobject unsafe, jobject field))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  UnsafeWrapper("Unsafe_FieldOffset");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  // tries (but fails) to be polymorphic between static and non-static:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  jlong offset = find_field_offset(field, -1, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  guarantee(offset == (jint)offset, "offset fits in 32 bits");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  return (jint)offset;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
//@deprecated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
UNSAFE_ENTRY(jobject, Unsafe_StaticFieldBaseFromClass(JNIEnv *env, jobject unsafe, jobject clazz))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  UnsafeWrapper("Unsafe_StaticFieldBase");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  if (clazz == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    THROW_0(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  }
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8490
diff changeset
   718
  return JNIHandles::make_local(env, JNIHandles::resolve_non_null(clazz));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   721
UNSAFE_ENTRY(void, Unsafe_EnsureClassInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  UnsafeWrapper("Unsafe_EnsureClassInitialized");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  if (clazz == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
    THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  oop mirror = JNIHandles::resolve_non_null(clazz);
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   727
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   728
  Klass* klass = java_lang_Class::as_Klass(mirror);
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14127
diff changeset
   729
  if (klass != NULL && klass->should_be_initialized()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   730
    InstanceKlass* k = InstanceKlass::cast(klass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
    k->initialize(CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  }
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   733
}
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   734
UNSAFE_END
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   735
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   736
UNSAFE_ENTRY(jboolean, Unsafe_ShouldBeInitialized(JNIEnv *env, jobject unsafe, jobject clazz)) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   737
  UnsafeWrapper("Unsafe_ShouldBeInitialized");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   738
  if (clazz == NULL) {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   739
    THROW_(vmSymbols::java_lang_NullPointerException(), false);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   740
  }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   741
  oop mirror = JNIHandles::resolve_non_null(clazz);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   742
  Klass* klass = java_lang_Class::as_Klass(mirror);
14488
ab48109f7d1b 8001471: Klass::cast() does nothing
hseigel
parents: 14127
diff changeset
   743
  if (klass != NULL && klass->should_be_initialized()) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   744
    return true;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   745
  }
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   746
  return false;
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
   747
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
static void getBaseAndScale(int& base, int& scale, jclass acls, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  if (acls == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  oop      mirror = JNIHandles::resolve_non_null(acls);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   755
  Klass* k      = java_lang_Class::as_Klass(mirror);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   756
  if (k == NULL || !k->oop_is_array()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
    THROW(vmSymbols::java_lang_InvalidClassException());
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   758
  } else if (k->oop_is_objArray()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    base  = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
   760
    scale = heapOopSize;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
   761
  } else if (k->oop_is_typeArray()) {
13952
e3cf184080bc 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass
coleenp
parents: 13728
diff changeset
   762
    TypeArrayKlass* tak = TypeArrayKlass::cast(k);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
    base  = tak->array_header_in_bytes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
    assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
    scale = (1 << tak->log2_element_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
    ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
UNSAFE_ENTRY(jint, Unsafe_ArrayBaseOffset(JNIEnv *env, jobject unsafe, jclass acls))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  UnsafeWrapper("Unsafe_ArrayBaseOffset");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  int base, scale;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  getBaseAndScale(base, scale, acls, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  return field_offset_from_byte_offset(base);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
UNSAFE_ENTRY(jint, Unsafe_ArrayIndexScale(JNIEnv *env, jobject unsafe, jclass acls))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  UnsafeWrapper("Unsafe_ArrayIndexScale");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  int base, scale;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
  getBaseAndScale(base, scale, acls, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  // This VM packs both fields and array elements down to the byte.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  // But watch out:  If this changes, so that array references for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  // a given primitive type (say, T_BOOLEAN) use different memory units
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  // than fields, this method MUST return zero for such arrays.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  // For example, the VM used to store sub-word sized fields in full
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  // words in the object layout, so that accessors like getByte(Object,int)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
  // did not really do what one might expect for arrays.  Therefore,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  // this function used to report a zero scale factor, so that the user
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  // would know not to attempt to access sub-word array elements.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
  // // Code for unpacked fields:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
  // if (scale < wordSize)  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  // The following allows for a pretty general fieldOffset cookie scheme,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  // but requires it to be linear in byte offset.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  return field_offset_from_byte_offset(scale) - field_offset_from_byte_offset(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
static inline void throw_new(JNIEnv *env, const char *ename) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
  char buf[100];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  strcpy(buf, "java/lang/");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  strcat(buf, ename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  jclass cls = env->FindClass(buf);
22786
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 20282
diff changeset
   806
  if (env->ExceptionCheck()) {
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 20282
diff changeset
   807
    env->ExceptionClear();
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 20282
diff changeset
   808
    tty->print_cr("Unsafe: cannot throw %s because FindClass has failed", buf);
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 20282
diff changeset
   809
    return;
86644d9539c2 8028785: [parfait] warnings from b116 for hotspot.src.share.vm.prims: JNI exception pending
ccheung
parents: 20282
diff changeset
   810
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  char* msg = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  env->ThrowNew(cls, msg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   815
static jclass Unsafe_DefineClass_impl(JNIEnv *env, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
    // Code lifted from JDK 1.3 ClassLoader.c
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
    jbyte *body;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
    char *utfName;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
    jclass result = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
    char buf[128];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
    if (UsePerfData) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
      ClassLoader::unsafe_defineClassCallCounter()->inc();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
    if (data == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
        throw_new(env, "NullPointerException");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
        return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    /* Work around 4153825. malloc crashes on Solaris when passed a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
     * negative size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
     */
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
    if (length < 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
        throw_new(env, "ArrayIndexOutOfBoundsException");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
        return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
   841
    body = NEW_C_HEAP_ARRAY(jbyte, length, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    if (body == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
        throw_new(env, "OutOfMemoryError");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
        return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
    env->GetByteArrayRegion(data, offset, length, body);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
    if (env->ExceptionOccurred())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
        goto free_body;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
    if (name != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
        uint len = env->GetStringUTFLength(name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
        int unicode_len = env->GetStringLength(name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
        if (len >= sizeof(buf)) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
   857
            utfName = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
            if (utfName == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
                throw_new(env, "OutOfMemoryError");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
                goto free_body;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
            utfName = buf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
        env->GetStringUTFRegion(name, 0, unicode_len, utfName);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
        //VerifyFixClassname(utfName);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
        for (uint i = 0; i < len; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
          if (utfName[i] == '.')   utfName[i] = '/';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
        utfName = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
    result = JVM_DefineClass(env, utfName, loader, body, length, pd);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
    if (utfName && utfName != buf)
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
   877
        FREE_C_HEAP_ARRAY(char, utfName, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
 free_body:
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
   880
    FREE_C_HEAP_ARRAY(jbyte, body, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
    return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   886
UNSAFE_ENTRY(jclass, Unsafe_DefineClass(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length, jobject loader, jobject pd))
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   887
  UnsafeWrapper("Unsafe_DefineClass");
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   888
  {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   889
    ThreadToNativeFromVM ttnfv(thread);
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   890
    return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd);
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   891
  }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   892
UNSAFE_END
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   893
25326
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   894
static jobject get_class_loader(JNIEnv* env, jclass cls) {
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   895
  if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   896
    return NULL;
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   897
  }
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   898
  Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   899
  oop loader = k->class_loader();
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   900
  return JNIHandles::make_local(env, loader);
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   901
}
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   902
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
UNSAFE_ENTRY(jclass, Unsafe_DefineClass0(JNIEnv *env, jobject unsafe, jstring name, jbyteArray data, int offset, int length))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  UnsafeWrapper("Unsafe_DefineClass");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
    ThreadToNativeFromVM ttnfv(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
    int depthFromDefineClass0 = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
    jclass  caller = JVM_GetCallerClass(env, depthFromDefineClass0);
25326
85b2f2e63e3e 6642881: Improve performance of Class.getClassLoader()
coleenp
parents: 25057
diff changeset
   910
    jobject loader = (caller == NULL) ? NULL : get_class_loader(env, caller);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
    jobject pd     = (caller == NULL) ? NULL : JVM_GetProtectionDomain(env, caller);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
   913
    return Unsafe_DefineClass_impl(env, name, data, offset, length, loader, pd);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   918
#define DAC_Args CLS"[B["OBJ
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   919
// define a class but do not make it known to the class loader or system dictionary
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   920
// - host_class:  supplies context for linkage, access control, protection domain, and class loader
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   921
// - data:  bytes of a class file, a raw memory address (length gives the number of bytes)
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   922
// - cp_patches:  where non-null entries exist, they replace corresponding CP entries in data
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   923
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   924
// When you load an anonymous class U, it works as if you changed its name just before loading,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   925
// to a name that you will never use again.  Since the name is lost, no other class can directly
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   926
// link to any member of U.  Just after U is loaded, the only way to use it is reflectively,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   927
// through java.lang.Class methods like Class.newInstance.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   928
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   929
// Access checks for linkage sites within U continue to follow the same rules as for named classes.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   930
// The package of an anonymous class is given by the package qualifier on the name under which it was loaded.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   931
// An anonymous class also has special privileges to access any member of its host class.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   932
// This is the main reason why this loading operation is unsafe.  The purpose of this is to
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   933
// allow language implementations to simulate "open classes"; a host class in effect gets
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   934
// new code when an anonymous class is loaded alongside it.  A less convenient but more
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   935
// standard way to do this is with reflection, which can also be set to ignore access
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   936
// restrictions.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   937
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   938
// Access into an anonymous class is possible only through reflection.  Therefore, there
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   939
// are no special access rules for calling into an anonymous class.  The relaxed access
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   940
// rule for the host class is applied in the opposite direction:  A host class reflectively
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   941
// access one of its anonymous classes.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   942
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   943
// If you load the same bytecodes twice, you get two different classes.  You can reload
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   944
// the same bytecodes with or without varying CP patches.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   945
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   946
// By using the CP patching array, you can have a new anonymous class U2 refer to an older one U1.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   947
// The bytecodes for U2 should refer to U1 by a symbolic name (doesn't matter what the name is).
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   948
// The CONSTANT_Class entry for that name can be patched to refer directly to U1.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   949
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   950
// This allows, for example, U2 to use U1 as a superclass or super-interface, or as
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   951
// an outer class (so that U2 is an anonymous inner class of anonymous U1).
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   952
// It is not possible for a named class, or an older anonymous class, to refer by
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   953
// name (via its CP) to a newer anonymous class.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   954
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   955
// CP patching may also be used to modify (i.e., hack) the names of methods, classes,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   956
// or type descriptors used in the loaded anonymous class.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   957
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   958
// Finally, CP patching may be used to introduce "live" objects into the constant pool,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   959
// instead of "dead" strings.  A compiled statement like println((Object)"hello") can
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   960
// be changed to println(greeting), where greeting is an arbitrary object created before
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   961
// the anonymous class is loaded.  This is useful in dynamic languages, in which
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   962
// various kinds of metaobjects must be introduced as constants into bytecode.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   963
// Note the cast (Object), which tells the verifier to expect an arbitrary object,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   964
// not just a literal string.  For such ldc instructions, the verifier uses the
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   965
// type Object instead of String, if the loaded constant is not in fact a String.
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   966
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
   967
static instanceKlassHandle
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   968
Unsafe_DefineAnonymousClass_impl(JNIEnv *env,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   969
                                 jclass host_class, jbyteArray data, jobjectArray cp_patches_jh,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   970
                                 HeapWord* *temp_alloc,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   971
                                 TRAPS) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   972
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   973
  if (UsePerfData) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   974
    ClassLoader::unsafe_defineClassCallCounter()->inc();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   975
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   976
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   977
  if (data == NULL) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   978
    THROW_0(vmSymbols::java_lang_NullPointerException());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   979
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   980
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   981
  jint length = typeArrayOop(JNIHandles::resolve_non_null(data))->length();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   982
  jint word_length = (length + sizeof(HeapWord)-1) / sizeof(HeapWord);
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
   983
  HeapWord* body = NEW_C_HEAP_ARRAY(HeapWord, word_length, mtInternal);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   984
  if (body == NULL) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   985
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   986
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   987
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   988
  // caller responsible to free it:
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   989
  (*temp_alloc) = body;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   990
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   991
  {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   992
    jbyte* array_base = typeArrayOop(JNIHandles::resolve_non_null(data))->byte_at_addr(0);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   993
    Copy::conjoint_words((HeapWord*) array_base, body, word_length);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   994
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   995
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   996
  u1* class_bytes = (u1*) body;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   997
  int class_bytes_length = (int) length;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   998
  if (class_bytes_length < 0)  class_bytes_length = 0;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
   999
  if (class_bytes == NULL
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1000
      || host_class == NULL
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1001
      || length != class_bytes_length)
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1002
    THROW_0(vmSymbols::java_lang_IllegalArgumentException());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1003
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1004
  objArrayHandle cp_patches_h;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1005
  if (cp_patches_jh != NULL) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1006
    oop p = JNIHandles::resolve_non_null(cp_patches_jh);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1007
    if (!p->is_objArray())
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1008
      THROW_0(vmSymbols::java_lang_IllegalArgumentException());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1009
    cp_patches_h = objArrayHandle(THREAD, (objArrayOop)p);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1010
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1011
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1012
  KlassHandle host_klass(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(host_class)));
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1013
  const char* host_source = host_klass->external_name();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1014
  Handle      host_loader(THREAD, host_klass->class_loader());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1015
  Handle      host_domain(THREAD, host_klass->protection_domain());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1016
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1017
  GrowableArray<Handle>* cp_patches = NULL;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1018
  if (cp_patches_h.not_null()) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1019
    int alen = cp_patches_h->length();
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1020
    for (int i = alen-1; i >= 0; i--) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1021
      oop p = cp_patches_h->obj_at(i);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1022
      if (p != NULL) {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1023
        Handle patch(THREAD, p);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1024
        if (cp_patches == NULL)
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1025
          cp_patches = new GrowableArray<Handle>(i+1, i+1, Handle());
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1026
        cp_patches->at_put(i, patch);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1027
      }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1028
    }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1029
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1030
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1031
  ClassFileStream st(class_bytes, class_bytes_length, (char*) host_source);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1032
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1033
  instanceKlassHandle anon_klass;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1034
  {
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7885
diff changeset
  1035
    Symbol* no_class_name = NULL;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1036
    Klass* anonk = SystemDictionary::parse_stream(no_class_name,
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1037
                                                    host_loader, host_domain,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1038
                                                    &st, host_klass, cp_patches,
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1039
                                                    CHECK_NULL);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1040
    if (anonk == NULL)  return NULL;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1041
    anon_klass = instanceKlassHandle(THREAD, anonk);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1042
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1043
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1044
  return anon_klass;
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1045
}
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1046
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1047
UNSAFE_ENTRY(jclass, Unsafe_DefineAnonymousClass(JNIEnv *env, jobject unsafe, jclass host_class, jbyteArray data, jobjectArray cp_patches_jh))
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1048
{
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1049
  instanceKlassHandle anon_klass;
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1050
  jobject res_jh = NULL;
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1051
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1052
  UnsafeWrapper("Unsafe_DefineAnonymousClass");
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1053
  ResourceMark rm(THREAD);
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1054
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1055
  HeapWord* temp_alloc = NULL;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1056
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1057
  anon_klass = Unsafe_DefineAnonymousClass_impl(env, host_class, data,
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1058
                                                cp_patches_jh,
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1059
                                                   &temp_alloc, THREAD);
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1060
  if (anon_klass() != NULL)
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1061
    res_jh = JNIHandles::make_local(env, anon_klass->java_mirror());
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1062
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1063
  // try/finally clause:
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1064
  if (temp_alloc != NULL) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 10967
diff changeset
  1065
    FREE_C_HEAP_ARRAY(HeapWord, temp_alloc, mtInternal);
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1066
  }
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1067
14588
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1068
  // The anonymous class loader data has been artificially been kept alive to
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1069
  // this point.   The mirror and any instances of this class have to keep
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1070
  // it alive afterwards.
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1071
  if (anon_klass() != NULL) {
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1072
    anon_klass->class_loader_data()->set_keep_alive(false);
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1073
  }
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1074
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1075
  // let caller initialize it as needed...
8ec26d2d9339 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap
coleenp
parents: 14488
diff changeset
  1076
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1077
  return (jclass) res_jh;
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1078
}
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1079
UNSAFE_END
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1080
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1081
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
UNSAFE_ENTRY(void, Unsafe_MonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  UnsafeWrapper("Unsafe_MonitorEnter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
    if (jobj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
      THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
    Handle obj(thread, JNIHandles::resolve_non_null(jobj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
    ObjectSynchronizer::jni_enter(obj, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
UNSAFE_ENTRY(jboolean, Unsafe_TryMonitorEnter(JNIEnv *env, jobject unsafe, jobject jobj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  UnsafeWrapper("Unsafe_TryMonitorEnter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
    if (jobj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
      THROW_(vmSymbols::java_lang_NullPointerException(), JNI_FALSE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
    Handle obj(thread, JNIHandles::resolve_non_null(jobj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
    bool res = ObjectSynchronizer::jni_try_enter(obj, CHECK_0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
    return (res ? JNI_TRUE : JNI_FALSE);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
UNSAFE_ENTRY(void, Unsafe_MonitorExit(JNIEnv *env, jobject unsafe, jobject jobj))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
  UnsafeWrapper("Unsafe_MonitorExit");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
    if (jobj == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
      THROW(vmSymbols::java_lang_NullPointerException());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
    Handle obj(THREAD, JNIHandles::resolve_non_null(jobj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1115
    ObjectSynchronizer::jni_exit(obj(), CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1116
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
UNSAFE_ENTRY(void, Unsafe_ThrowException(JNIEnv *env, jobject unsafe, jthrowable thr))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
  UnsafeWrapper("Unsafe_ThrowException");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1122
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
    ThreadToNativeFromVM ttnfv(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
    env->Throw(thr);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1125
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1126
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1127
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1128
// JSR166 ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1129
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1130
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jobject e_h, jobject x_h))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1131
  UnsafeWrapper("Unsafe_CompareAndSwapObject");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1132
  oop x = JNIHandles::resolve(x_h);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1133
  oop e = JNIHandles::resolve(e_h);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1134
  oop p = JNIHandles::resolve(obj);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1135
  HeapWord* addr = (HeapWord *)index_oop_from_field_offset_long(p, offset);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13391
diff changeset
  1136
  oop res = oopDesc::atomic_compare_exchange_oop(x, addr, e, true);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1137
  jboolean success  = (res == e);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
  if (success)
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 1
diff changeset
  1139
    update_barrier_set((void*)addr, x);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
  return success;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
  oop p = JNIHandles::resolve(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapLong(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jlong e, jlong x))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  UnsafeWrapper("Unsafe_CompareAndSwapLong");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
  Handle p (THREAD, JNIHandles::resolve(obj));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  jlong* addr = (jlong*)(index_oop_from_field_offset_long(p(), offset));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  if (VM_Version::supports_cx8())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
    return (jlong)(Atomic::cmpxchg(x, addr, e)) == e;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
    jboolean success = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
    ObjectLocker ol(p, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
    if (*addr == e) { *addr = x; success = true; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
    return success;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
UNSAFE_ENTRY(void, Unsafe_Park(JNIEnv *env, jobject unsafe, jboolean isAbsolute, jlong time))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
  UnsafeWrapper("Unsafe_Park");
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17881
diff changeset
  1166
  EventThreadPark event;
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22786
diff changeset
  1167
  HOTSPOT_THREAD_PARK_BEGIN((uintptr_t) thread->parker(), (int) isAbsolute, time);
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22786
diff changeset
  1168
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
  JavaThreadParkedState jtps(thread, time != 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  thread->parker()->park(isAbsolute != 0, time);
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22786
diff changeset
  1171
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22786
diff changeset
  1172
  HOTSPOT_THREAD_PARK_END((uintptr_t) thread->parker());
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17881
diff changeset
  1173
  if (event.should_commit()) {
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17881
diff changeset
  1174
    oop obj = thread->current_park_blocker();
20282
7f9cbdf89af2 7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents: 18025
diff changeset
  1175
    event.set_klass((obj != NULL) ? obj->klass() : NULL);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17881
diff changeset
  1176
    event.set_timeout(time);
20282
7f9cbdf89af2 7195622: CheckUnhandledOops has limited usefulness now
hseigel
parents: 18025
diff changeset
  1177
    event.set_address((obj != NULL) ? (TYPE_ADDRESS) cast_from_oop<uintptr_t>(obj) : 0);
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17881
diff changeset
  1178
    event.commit();
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17881
diff changeset
  1179
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
UNSAFE_ENTRY(void, Unsafe_Unpark(JNIEnv *env, jobject unsafe, jobject jthread))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  UnsafeWrapper("Unsafe_Unpark");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
  Parker* p = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
  if (jthread != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
    oop java_thread = JNIHandles::resolve_non_null(jthread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
    if (java_thread != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
      jlong lp = java_lang_Thread::park_event(java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
      if (lp != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
        // This cast is OK even though the jlong might have been read
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
        // non-atomically on 32bit systems, since there, one word will
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
        // always be zero anyway and the value set is always the same
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
        p = (Parker*)addr_from_java(lp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
        // Grab lock if apparently null or using older version of library
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
        MutexLocker mu(Threads_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
        java_thread = JNIHandles::resolve_non_null(jthread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
        if (java_thread != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
          JavaThread* thr = java_lang_Thread::thread(java_thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
          if (thr != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
            p = thr->parker();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
            if (p != NULL) { // Bind to Java thread for next time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
              java_lang_Thread::set_park_event(java_thread, addr_to_java(p));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  if (p != NULL) {
22796
bb0ea482a99e 8034080: Remove the USDT1 dtrace code from Hotspot
sla
parents: 22786
diff changeset
  1211
    HOTSPOT_THREAD_UNPARK((uintptr_t) p);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
    p->unpark();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
UNSAFE_ENTRY(jint, Unsafe_Loadavg(JNIEnv *env, jobject unsafe, jdoubleArray loadavg, jint nelem))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  UnsafeWrapper("Unsafe_Loadavg");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
  const int max_nelem = 3;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
  double la[max_nelem];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
  jint ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
  typeArrayOop a = typeArrayOop(JNIHandles::resolve_non_null(loadavg));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
  assert(a->is_typeArray(), "must be type array");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
  if (nelem < 0 || nelem > max_nelem || a->length() < nelem) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
    ThreadToNativeFromVM ttnfv(thread);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
    throw_new(env, "ArrayIndexOutOfBoundsException");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  ret = os::loadavg(la, nelem);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
  if (ret == -1) return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
  // if successful, ret is the number of samples actually retrieved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1235
  assert(ret >= 0 && ret <= max_nelem, "Unexpected loadavg return value");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1236
  switch(ret) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1237
    case 3: a->double_at_put(2, (jdouble)la[2]); // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
    case 2: a->double_at_put(1, (jdouble)la[1]); // fall through
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
    case 1: a->double_at_put(0, (jdouble)la[0]); break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
  return ret;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
UNSAFE_ENTRY(void, Unsafe_PrefetchRead(JNIEnv* env, jclass ignored, jobject obj, jlong offset))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
  UnsafeWrapper("Unsafe_PrefetchRead");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
  oop p = JNIHandles::resolve(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
  void* addr = index_oop_from_field_offset_long(p, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
  Prefetch::read(addr, (intx)offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1249
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1250
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1251
UNSAFE_ENTRY(void, Unsafe_PrefetchWrite(JNIEnv* env, jclass ignored, jobject obj, jlong offset))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1252
  UnsafeWrapper("Unsafe_PrefetchWrite");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1253
  oop p = JNIHandles::resolve(obj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1254
  void* addr = index_oop_from_field_offset_long(p, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1255
  Prefetch::write(addr, (intx)offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1256
UNSAFE_END
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
/// JVM_RegisterUnsafeMethods
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
#define ADR "J"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
#define LANG "Ljava/lang/"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
#define OBJ LANG"Object;"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
#define CLS LANG"Class;"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
#define CTR LANG"reflect/Constructor;"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
#define FLD LANG"reflect/Field;"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1269
#define MTH LANG"reflect/Method;"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
#define THR LANG"Throwable;"
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
#define DC0_Args LANG"String;[BII"
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1273
#define DC_Args  DC0_Args LANG"ClassLoader;" "Ljava/security/ProtectionDomain;"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
#define CC (char*)  /*cast a literal from (const char*)*/
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1276
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1277
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
// define deprecated accessors for compabitility with 1.4.0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
#define DECLARE_GETSETOOP_140(Boolean, Z) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
    {CC"get"#Boolean,      CC"("OBJ"I)"#Z,      FN_PTR(Unsafe_Get##Boolean##140)}, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1281
    {CC"put"#Boolean,      CC"("OBJ"I"#Z")V",   FN_PTR(Unsafe_Set##Boolean##140)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1282
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1283
// Note:  In 1.4.1, getObject and kin take both int and long offsets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1284
#define DECLARE_GETSETOOP_141(Boolean, Z) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1285
    {CC"get"#Boolean,      CC"("OBJ"J)"#Z,      FN_PTR(Unsafe_Get##Boolean)}, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1286
    {CC"put"#Boolean,      CC"("OBJ"J"#Z")V",   FN_PTR(Unsafe_Set##Boolean)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1287
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1288
// Note:  In 1.5.0, there are volatile versions too
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1289
#define DECLARE_GETSETOOP(Boolean, Z) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1290
    {CC"get"#Boolean,      CC"("OBJ"J)"#Z,      FN_PTR(Unsafe_Get##Boolean)}, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1291
    {CC"put"#Boolean,      CC"("OBJ"J"#Z")V",   FN_PTR(Unsafe_Set##Boolean)}, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1292
    {CC"get"#Boolean"Volatile",      CC"("OBJ"J)"#Z,      FN_PTR(Unsafe_Get##Boolean##Volatile)}, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1293
    {CC"put"#Boolean"Volatile",      CC"("OBJ"J"#Z")V",   FN_PTR(Unsafe_Set##Boolean##Volatile)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1294
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1295
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1296
#define DECLARE_GETSETNATIVE(Byte, B) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1297
    {CC"get"#Byte,         CC"("ADR")"#B,       FN_PTR(Unsafe_GetNative##Byte)}, \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1298
    {CC"put"#Byte,         CC"("ADR#B")V",      FN_PTR(Unsafe_SetNative##Byte)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1299
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1300
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1301
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1302
// These are the methods for 1.4.0
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1303
static JNINativeMethod methods_140[] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1304
    DECLARE_GETSETOOP_140(Boolean, Z),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1305
    DECLARE_GETSETOOP_140(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1306
    DECLARE_GETSETOOP_140(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1307
    DECLARE_GETSETOOP_140(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1308
    DECLARE_GETSETOOP_140(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1309
    DECLARE_GETSETOOP_140(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1310
    DECLARE_GETSETOOP_140(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1311
    DECLARE_GETSETOOP_140(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
    DECLARE_GETSETNATIVE(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
    DECLARE_GETSETNATIVE(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
    DECLARE_GETSETNATIVE(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
    DECLARE_GETSETNATIVE(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
    DECLARE_GETSETNATIVE(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
    DECLARE_GETSETNATIVE(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
    DECLARE_GETSETNATIVE(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
    {CC"getAddress",         CC"("ADR")"ADR,             FN_PTR(Unsafe_GetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
    {CC"putAddress",         CC"("ADR""ADR")V",          FN_PTR(Unsafe_SetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
    {CC"allocateMemory",     CC"(J)"ADR,                 FN_PTR(Unsafe_AllocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
    {CC"reallocateMemory",   CC"("ADR"J)"ADR,            FN_PTR(Unsafe_ReallocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
    {CC"freeMemory",         CC"("ADR")V",               FN_PTR(Unsafe_FreeMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1328
    {CC"fieldOffset",        CC"("FLD")I",               FN_PTR(Unsafe_FieldOffset)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1329
    {CC"staticFieldBase",    CC"("CLS")"OBJ,             FN_PTR(Unsafe_StaticFieldBaseFromClass)},
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
    {CC"ensureClassInitialized",CC"("CLS")V",            FN_PTR(Unsafe_EnsureClassInitialized)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
    {CC"arrayBaseOffset",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayBaseOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
    {CC"arrayIndexScale",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayIndexScale)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
    {CC"addressSize",        CC"()I",                    FN_PTR(Unsafe_AddressSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
    {CC"pageSize",           CC"()I",                    FN_PTR(Unsafe_PageSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
    {CC"defineClass",        CC"("DC0_Args")"CLS,        FN_PTR(Unsafe_DefineClass0)},
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1337
    {CC"defineClass",        CC"("DC_Args")"CLS,         FN_PTR(Unsafe_DefineClass)},
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
    {CC"allocateInstance",   CC"("CLS")"OBJ,             FN_PTR(Unsafe_AllocateInstance)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
    {CC"monitorEnter",       CC"("OBJ")V",               FN_PTR(Unsafe_MonitorEnter)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
    {CC"monitorExit",        CC"("OBJ")V",               FN_PTR(Unsafe_MonitorExit)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
    {CC"throwException",     CC"("THR")V",               FN_PTR(Unsafe_ThrowException)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1344
// These are the methods prior to the JSR 166 changes in 1.5.0
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
static JNINativeMethod methods_141[] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
    {CC"getObject",        CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
    {CC"putObject",        CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
    DECLARE_GETSETOOP_141(Boolean, Z),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
    DECLARE_GETSETOOP_141(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
    DECLARE_GETSETOOP_141(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
    DECLARE_GETSETOOP_141(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
    DECLARE_GETSETOOP_141(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
    DECLARE_GETSETOOP_141(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
    DECLARE_GETSETOOP_141(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
    DECLARE_GETSETOOP_141(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
    DECLARE_GETSETNATIVE(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
    DECLARE_GETSETNATIVE(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
    DECLARE_GETSETNATIVE(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
    DECLARE_GETSETNATIVE(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
    DECLARE_GETSETNATIVE(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
    DECLARE_GETSETNATIVE(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
    DECLARE_GETSETNATIVE(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
    {CC"getAddress",         CC"("ADR")"ADR,             FN_PTR(Unsafe_GetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
    {CC"putAddress",         CC"("ADR""ADR")V",          FN_PTR(Unsafe_SetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
    {CC"allocateMemory",     CC"(J)"ADR,                 FN_PTR(Unsafe_AllocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
    {CC"reallocateMemory",   CC"("ADR"J)"ADR,            FN_PTR(Unsafe_ReallocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
    {CC"freeMemory",         CC"("ADR")V",               FN_PTR(Unsafe_FreeMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
    {CC"objectFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_ObjectFieldOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
    {CC"staticFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_StaticFieldOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
    {CC"staticFieldBase",    CC"("FLD")"OBJ,             FN_PTR(Unsafe_StaticFieldBaseFromField)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
    {CC"ensureClassInitialized",CC"("CLS")V",            FN_PTR(Unsafe_EnsureClassInitialized)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
    {CC"arrayBaseOffset",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayBaseOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
    {CC"arrayIndexScale",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayIndexScale)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
    {CC"addressSize",        CC"()I",                    FN_PTR(Unsafe_AddressSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
    {CC"pageSize",           CC"()I",                    FN_PTR(Unsafe_PageSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
    {CC"defineClass",        CC"("DC0_Args")"CLS,        FN_PTR(Unsafe_DefineClass0)},
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1383
    {CC"defineClass",        CC"("DC_Args")"CLS,         FN_PTR(Unsafe_DefineClass)},
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
    {CC"allocateInstance",   CC"("CLS")"OBJ,             FN_PTR(Unsafe_AllocateInstance)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
    {CC"monitorEnter",       CC"("OBJ")V",               FN_PTR(Unsafe_MonitorEnter)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
    {CC"monitorExit",        CC"("OBJ")V",               FN_PTR(Unsafe_MonitorExit)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
    {CC"throwException",     CC"("THR")V",               FN_PTR(Unsafe_ThrowException)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1391
// These are the methods prior to the JSR 166 changes in 1.6.0
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
static JNINativeMethod methods_15[] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1393
    {CC"getObject",        CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1394
    {CC"putObject",        CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1395
    {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObjectVolatile)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
    {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObjectVolatile)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
    DECLARE_GETSETOOP(Boolean, Z),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
    DECLARE_GETSETOOP(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
    DECLARE_GETSETOOP(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
    DECLARE_GETSETOOP(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
    DECLARE_GETSETOOP(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
    DECLARE_GETSETOOP(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
    DECLARE_GETSETOOP(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
    DECLARE_GETSETOOP(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
    DECLARE_GETSETNATIVE(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
    DECLARE_GETSETNATIVE(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
    DECLARE_GETSETNATIVE(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1411
    DECLARE_GETSETNATIVE(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1412
    DECLARE_GETSETNATIVE(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1413
    DECLARE_GETSETNATIVE(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
    DECLARE_GETSETNATIVE(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
    {CC"getAddress",         CC"("ADR")"ADR,             FN_PTR(Unsafe_GetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
    {CC"putAddress",         CC"("ADR""ADR")V",          FN_PTR(Unsafe_SetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
    {CC"allocateMemory",     CC"(J)"ADR,                 FN_PTR(Unsafe_AllocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
    {CC"reallocateMemory",   CC"("ADR"J)"ADR,            FN_PTR(Unsafe_ReallocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
    {CC"freeMemory",         CC"("ADR")V",               FN_PTR(Unsafe_FreeMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1423
    {CC"objectFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_ObjectFieldOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
    {CC"staticFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_StaticFieldOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1425
    {CC"staticFieldBase",    CC"("FLD")"OBJ,             FN_PTR(Unsafe_StaticFieldBaseFromField)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
    {CC"ensureClassInitialized",CC"("CLS")V",            FN_PTR(Unsafe_EnsureClassInitialized)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
    {CC"arrayBaseOffset",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayBaseOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
    {CC"arrayIndexScale",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayIndexScale)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
    {CC"addressSize",        CC"()I",                    FN_PTR(Unsafe_AddressSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
    {CC"pageSize",           CC"()I",                    FN_PTR(Unsafe_PageSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
    {CC"defineClass",        CC"("DC0_Args")"CLS,        FN_PTR(Unsafe_DefineClass0)},
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1433
    {CC"defineClass",        CC"("DC_Args")"CLS,         FN_PTR(Unsafe_DefineClass)},
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
    {CC"allocateInstance",   CC"("CLS")"OBJ,             FN_PTR(Unsafe_AllocateInstance)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
    {CC"monitorEnter",       CC"("OBJ")V",               FN_PTR(Unsafe_MonitorEnter)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
    {CC"monitorExit",        CC"("OBJ")V",               FN_PTR(Unsafe_MonitorExit)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
    {CC"throwException",     CC"("THR")V",               FN_PTR(Unsafe_ThrowException)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
    {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z",  FN_PTR(Unsafe_CompareAndSwapObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1439
    {CC"compareAndSwapInt",  CC"("OBJ"J""I""I"")Z",      FN_PTR(Unsafe_CompareAndSwapInt)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
    {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z",      FN_PTR(Unsafe_CompareAndSwapLong)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
    {CC"park",               CC"(ZJ)V",                  FN_PTR(Unsafe_Park)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
    {CC"unpark",             CC"("OBJ")V",               FN_PTR(Unsafe_Unpark)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1445
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1446
// These are the methods for 1.6.0 and 1.7.0
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1447
static JNINativeMethod methods_16[] = {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1448
    {CC"getObject",        CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1449
    {CC"putObject",        CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1450
    {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObjectVolatile)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1451
    {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObjectVolatile)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1453
    DECLARE_GETSETOOP(Boolean, Z),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1454
    DECLARE_GETSETOOP(Byte, B),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1455
    DECLARE_GETSETOOP(Short, S),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1456
    DECLARE_GETSETOOP(Char, C),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1457
    DECLARE_GETSETOOP(Int, I),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1458
    DECLARE_GETSETOOP(Long, J),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1459
    DECLARE_GETSETOOP(Float, F),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1460
    DECLARE_GETSETOOP(Double, D),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1461
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1462
    DECLARE_GETSETNATIVE(Byte, B),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1463
    DECLARE_GETSETNATIVE(Short, S),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1464
    DECLARE_GETSETNATIVE(Char, C),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1465
    DECLARE_GETSETNATIVE(Int, I),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1466
    DECLARE_GETSETNATIVE(Long, J),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1467
    DECLARE_GETSETNATIVE(Float, F),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1468
    DECLARE_GETSETNATIVE(Double, D),
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1469
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1470
    {CC"getAddress",         CC"("ADR")"ADR,             FN_PTR(Unsafe_GetNativeAddress)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1471
    {CC"putAddress",         CC"("ADR""ADR")V",          FN_PTR(Unsafe_SetNativeAddress)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1472
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1473
    {CC"allocateMemory",     CC"(J)"ADR,                 FN_PTR(Unsafe_AllocateMemory)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1474
    {CC"reallocateMemory",   CC"("ADR"J)"ADR,            FN_PTR(Unsafe_ReallocateMemory)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1475
    {CC"freeMemory",         CC"("ADR")V",               FN_PTR(Unsafe_FreeMemory)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1476
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1477
    {CC"objectFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_ObjectFieldOffset)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1478
    {CC"staticFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_StaticFieldOffset)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1479
    {CC"staticFieldBase",    CC"("FLD")"OBJ,             FN_PTR(Unsafe_StaticFieldBaseFromField)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1480
    {CC"ensureClassInitialized",CC"("CLS")V",            FN_PTR(Unsafe_EnsureClassInitialized)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1481
    {CC"arrayBaseOffset",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayBaseOffset)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1482
    {CC"arrayIndexScale",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayIndexScale)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1483
    {CC"addressSize",        CC"()I",                    FN_PTR(Unsafe_AddressSize)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1484
    {CC"pageSize",           CC"()I",                    FN_PTR(Unsafe_PageSize)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1485
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1486
    {CC"defineClass",        CC"("DC0_Args")"CLS,        FN_PTR(Unsafe_DefineClass0)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1487
    {CC"defineClass",        CC"("DC_Args")"CLS,         FN_PTR(Unsafe_DefineClass)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1488
    {CC"allocateInstance",   CC"("CLS")"OBJ,             FN_PTR(Unsafe_AllocateInstance)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1489
    {CC"monitorEnter",       CC"("OBJ")V",               FN_PTR(Unsafe_MonitorEnter)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1490
    {CC"monitorExit",        CC"("OBJ")V",               FN_PTR(Unsafe_MonitorExit)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1491
    {CC"tryMonitorEnter",    CC"("OBJ")Z",               FN_PTR(Unsafe_TryMonitorEnter)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1492
    {CC"throwException",     CC"("THR")V",               FN_PTR(Unsafe_ThrowException)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1493
    {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z",  FN_PTR(Unsafe_CompareAndSwapObject)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1494
    {CC"compareAndSwapInt",  CC"("OBJ"J""I""I"")Z",      FN_PTR(Unsafe_CompareAndSwapInt)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1495
    {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z",      FN_PTR(Unsafe_CompareAndSwapLong)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1496
    {CC"putOrderedObject",   CC"("OBJ"J"OBJ")V",         FN_PTR(Unsafe_SetOrderedObject)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1497
    {CC"putOrderedInt",      CC"("OBJ"JI)V",             FN_PTR(Unsafe_SetOrderedInt)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1498
    {CC"putOrderedLong",     CC"("OBJ"JJ)V",             FN_PTR(Unsafe_SetOrderedLong)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1499
    {CC"park",               CC"(ZJ)V",                  FN_PTR(Unsafe_Park)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1500
    {CC"unpark",             CC"("OBJ")V",               FN_PTR(Unsafe_Unpark)}
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1501
};
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1502
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1503
// These are the methods for 1.8.0
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1504
static JNINativeMethod methods_18[] = {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1505
    {CC"getObject",        CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObject)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1506
    {CC"putObject",        CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObject)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1507
    {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObjectVolatile)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1508
    {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObjectVolatile)},
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
    DECLARE_GETSETOOP(Boolean, Z),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
    DECLARE_GETSETOOP(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1512
    DECLARE_GETSETOOP(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1513
    DECLARE_GETSETOOP(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1514
    DECLARE_GETSETOOP(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1515
    DECLARE_GETSETOOP(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1516
    DECLARE_GETSETOOP(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
    DECLARE_GETSETOOP(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
    DECLARE_GETSETNATIVE(Byte, B),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
    DECLARE_GETSETNATIVE(Short, S),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
    DECLARE_GETSETNATIVE(Char, C),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
    DECLARE_GETSETNATIVE(Int, I),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
    DECLARE_GETSETNATIVE(Long, J),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
    DECLARE_GETSETNATIVE(Float, F),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
    DECLARE_GETSETNATIVE(Double, D),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1526
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1527
    {CC"getAddress",         CC"("ADR")"ADR,             FN_PTR(Unsafe_GetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    {CC"putAddress",         CC"("ADR""ADR")V",          FN_PTR(Unsafe_SetNativeAddress)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1530
    {CC"allocateMemory",     CC"(J)"ADR,                 FN_PTR(Unsafe_AllocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
    {CC"reallocateMemory",   CC"("ADR"J)"ADR,            FN_PTR(Unsafe_ReallocateMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
    {CC"freeMemory",         CC"("ADR")V",               FN_PTR(Unsafe_FreeMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
    {CC"objectFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_ObjectFieldOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
    {CC"staticFieldOffset",  CC"("FLD")J",               FN_PTR(Unsafe_StaticFieldOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    {CC"staticFieldBase",    CC"("FLD")"OBJ,             FN_PTR(Unsafe_StaticFieldBaseFromField)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
    {CC"ensureClassInitialized",CC"("CLS")V",            FN_PTR(Unsafe_EnsureClassInitialized)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
    {CC"arrayBaseOffset",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayBaseOffset)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
    {CC"arrayIndexScale",    CC"("CLS")I",               FN_PTR(Unsafe_ArrayIndexScale)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
    {CC"addressSize",        CC"()I",                    FN_PTR(Unsafe_AddressSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
    {CC"pageSize",           CC"()I",                    FN_PTR(Unsafe_PageSize)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1543
    {CC"defineClass",        CC"("DC_Args")"CLS,         FN_PTR(Unsafe_DefineClass)},
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
    {CC"allocateInstance",   CC"("CLS")"OBJ,             FN_PTR(Unsafe_AllocateInstance)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
    {CC"monitorEnter",       CC"("OBJ")V",               FN_PTR(Unsafe_MonitorEnter)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
    {CC"monitorExit",        CC"("OBJ")V",               FN_PTR(Unsafe_MonitorExit)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
    {CC"tryMonitorEnter",    CC"("OBJ")Z",               FN_PTR(Unsafe_TryMonitorEnter)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
    {CC"throwException",     CC"("THR")V",               FN_PTR(Unsafe_ThrowException)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
    {CC"compareAndSwapObject", CC"("OBJ"J"OBJ""OBJ")Z",  FN_PTR(Unsafe_CompareAndSwapObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1550
    {CC"compareAndSwapInt",  CC"("OBJ"J""I""I"")Z",      FN_PTR(Unsafe_CompareAndSwapInt)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1551
    {CC"compareAndSwapLong", CC"("OBJ"J""J""J"")Z",      FN_PTR(Unsafe_CompareAndSwapLong)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1552
    {CC"putOrderedObject",   CC"("OBJ"J"OBJ")V",         FN_PTR(Unsafe_SetOrderedObject)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1553
    {CC"putOrderedInt",      CC"("OBJ"JI)V",             FN_PTR(Unsafe_SetOrderedInt)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1554
    {CC"putOrderedLong",     CC"("OBJ"JJ)V",             FN_PTR(Unsafe_SetOrderedLong)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1555
    {CC"park",               CC"(ZJ)V",                  FN_PTR(Unsafe_Park)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
    {CC"unpark",             CC"("OBJ")V",               FN_PTR(Unsafe_Unpark)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
JNINativeMethod loadavg_method[] = {
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1560
    {CC"getLoadAverage",     CC"([DI)I",                 FN_PTR(Unsafe_Loadavg)}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
JNINativeMethod prefetch_methods[] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
    {CC"prefetchRead",       CC"("OBJ"J)V",              FN_PTR(Unsafe_PrefetchRead)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
    {CC"prefetchWrite",      CC"("OBJ"J)V",              FN_PTR(Unsafe_PrefetchWrite)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
    {CC"prefetchReadStatic", CC"("OBJ"J)V",              FN_PTR(Unsafe_PrefetchRead)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
    {CC"prefetchWriteStatic",CC"("OBJ"J)V",              FN_PTR(Unsafe_PrefetchWrite)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1570
JNINativeMethod memcopy_methods_17[] = {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
    {CC"copyMemory",         CC"("OBJ"J"OBJ"JJ)V",       FN_PTR(Unsafe_CopyMemory2)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
    {CC"setMemory",          CC"("OBJ"JJB)V",            FN_PTR(Unsafe_SetMemory2)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
JNINativeMethod memcopy_methods_15[] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
    {CC"setMemory",          CC"("ADR"JB)V",             FN_PTR(Unsafe_SetMemory)},
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
    {CC"copyMemory",         CC"("ADR ADR"J)V",          FN_PTR(Unsafe_CopyMemory)}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
1550
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1580
JNINativeMethod anonk_methods[] = {
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1581
    {CC"defineAnonymousClass", CC"("DAC_Args")"CLS,      FN_PTR(Unsafe_DefineAnonymousClass)},
be2fc37a817f 6653858: dynamic languages need to be able to load anonymous classes
jrose
parents: 1388
diff changeset
  1582
};
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1583
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
  1584
JNINativeMethod lform_methods[] = {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
  1585
    {CC"shouldBeInitialized",CC"("CLS")Z",               FN_PTR(Unsafe_ShouldBeInitialized)},
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
  1586
};
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13295
diff changeset
  1587
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1588
JNINativeMethod fence_methods[] = {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1589
    {CC"loadFence",          CC"()V",                    FN_PTR(Unsafe_LoadFence)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1590
    {CC"storeFence",         CC"()V",                    FN_PTR(Unsafe_StoreFence)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1591
    {CC"fullFence",          CC"()V",                    FN_PTR(Unsafe_FullFence)},
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1592
};
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1593
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
#undef CC
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
#undef FN_PTR
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
#undef ADR
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
#undef LANG
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
#undef OBJ
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
#undef CLS
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
#undef CTR
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
#undef FLD
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
#undef MTH
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
#undef THR
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
#undef DC0_Args
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1606
#undef DC_Args
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
#undef DECLARE_GETSETOOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
#undef DECLARE_GETSETNATIVE
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1612
/**
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1613
 * Helper method to register native methods.
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1614
 */
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1615
static bool register_natives(const char* message, JNIEnv* env, jclass clazz, const JNINativeMethod* methods, jint nMethods) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1616
  int status = env->RegisterNatives(clazz, methods, nMethods);
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1617
  if (status < 0 || env->ExceptionOccurred()) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1618
    if (PrintMiscellaneous && (Verbose || WizardMode)) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1619
      tty->print_cr("Unsafe:  failed registering %s", message);
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1620
    }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1621
    env->ExceptionClear();
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1622
    return false;
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1623
  } else {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1624
    if (PrintMiscellaneous && (Verbose || WizardMode)) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1625
      tty->print_cr("Unsafe:  successfully registered %s", message);
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1626
    }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1627
    return true;
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1628
  }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1629
}
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1630
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1631
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1632
// This one function is exported, used by NativeLookup.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1633
// The Unsafe_xxx functions above are called only from the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1634
// The optimizer looks at names and signatures to recognize
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1635
// individual functions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1636
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
JVM_ENTRY(void, JVM_RegisterUnsafeMethods(JNIEnv *env, jclass unsafecls))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
  UnsafeWrapper("JVM_RegisterUnsafeMethods");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
    ThreadToNativeFromVM ttnfv(thread);
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1641
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1642
    // Unsafe methods
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
    {
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1644
      bool success = false;
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1645
      // We need to register the 1.6 methods first because the 1.8 methods would register fine on 1.7 and 1.6
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1646
      if (!success) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1647
        success = register_natives("1.6 methods",   env, unsafecls, methods_16,  sizeof(methods_16)/sizeof(JNINativeMethod));
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1648
      }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1649
      if (!success) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1650
        success = register_natives("1.8 methods",   env, unsafecls, methods_18,  sizeof(methods_18)/sizeof(JNINativeMethod));
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1651
      }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1652
      if (!success) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1653
        success = register_natives("1.5 methods",   env, unsafecls, methods_15,  sizeof(methods_15)/sizeof(JNINativeMethod));
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1654
      }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1655
      if (!success) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1656
        success = register_natives("1.4.1 methods", env, unsafecls, methods_141, sizeof(methods_141)/sizeof(JNINativeMethod));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
      }
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1658
      if (!success) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1659
        success = register_natives("1.4.0 methods", env, unsafecls, methods_140, sizeof(methods_140)/sizeof(JNINativeMethod));
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1660
      }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1661
      guarantee(success, "register unsafe natives");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
    }
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1663
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1664
    // Unsafe.getLoadAverage
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1665
    register_natives("1.6 loadavg method", env, unsafecls, loadavg_method, sizeof(loadavg_method)/sizeof(JNINativeMethod));
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1666
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1667
    // Prefetch methods
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1668
    register_natives("1.6 prefetch methods", env, unsafecls, prefetch_methods, sizeof(prefetch_methods)/sizeof(JNINativeMethod));
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1669
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1670
    // Memory copy methods
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
    {
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1672
      bool success = false;
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1673
      if (!success) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1674
        success = register_natives("1.7 memory copy methods", env, unsafecls, memcopy_methods_17, sizeof(memcopy_methods_17)/sizeof(JNINativeMethod));
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1675
      }
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1676
      if (!success) {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1677
        success = register_natives("1.5 memory copy methods", env, unsafecls, memcopy_methods_15, sizeof(memcopy_methods_15)/sizeof(JNINativeMethod));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
    }
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1680
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1681
    // Unsafe.defineAnonymousClass
24322
c2978d1578e3 8036956: remove EnableInvokeDynamic flag
anoll
parents: 22881
diff changeset
  1682
    register_natives("1.7 define anonymous class method", env, unsafecls, anonk_methods, sizeof(anonk_methods)/sizeof(JNINativeMethod));
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1683
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1684
    // Unsafe.shouldBeInitialized
24322
c2978d1578e3 8036956: remove EnableInvokeDynamic flag
anoll
parents: 22881
diff changeset
  1685
    register_natives("1.7 LambdaForm support", env, unsafecls, lform_methods, sizeof(lform_methods)/sizeof(JNINativeMethod));
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1686
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1687
    // Fence methods
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15482
diff changeset
  1688
    register_natives("1.8 fence methods", env, unsafecls, fence_methods, sizeof(fence_methods)/sizeof(JNINativeMethod));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
JVM_END