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