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