Mercurial > hg > truffle
annotate src/share/vm/runtime/javaCalls.hpp @ 6862:8a5ea0a9ccc4
7127708: G1: change task num types from int to uint in concurrent mark
Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich.
Reviewed-by: johnc
Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>
| author | johnc |
|---|---|
| date | Sat, 06 Oct 2012 01:17:44 -0700 |
| parents | da91efe96a93 |
| children | e522a00b91aa f34d701e952e |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
2 * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1506
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_RUNTIME_JAVACALLS_HPP |
| 26 #define SHARE_VM_RUNTIME_JAVACALLS_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
29 #include "oops/method.hpp" |
| 1972 | 30 #include "runtime/handles.hpp" |
| 31 #include "runtime/javaFrameAnchor.hpp" | |
| 32 #include "runtime/vmThread.hpp" | |
| 33 #ifdef TARGET_ARCH_x86 | |
| 34 # include "jniTypes_x86.hpp" | |
| 35 #endif | |
| 36 #ifdef TARGET_ARCH_sparc | |
| 37 # include "jniTypes_sparc.hpp" | |
| 38 #endif | |
| 39 #ifdef TARGET_ARCH_zero | |
| 40 # include "jniTypes_zero.hpp" | |
| 41 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
42 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
43 # include "jniTypes_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
44 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
45 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
46 # include "jniTypes_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
2177
diff
changeset
|
47 #endif |
| 1972 | 48 #ifdef TARGET_OS_FAMILY_linux |
| 49 # include "thread_linux.inline.hpp" | |
| 50 #endif | |
| 51 #ifdef TARGET_OS_FAMILY_solaris | |
| 52 # include "thread_solaris.inline.hpp" | |
| 53 #endif | |
| 54 #ifdef TARGET_OS_FAMILY_windows | |
| 55 # include "thread_windows.inline.hpp" | |
| 56 #endif | |
| 3960 | 57 #ifdef TARGET_OS_FAMILY_bsd |
| 58 # include "thread_bsd.inline.hpp" | |
| 59 #endif | |
| 1972 | 60 |
| 0 | 61 // A JavaCallWrapper is constructed before each JavaCall and destructed after the call. |
| 62 // Its purpose is to allocate/deallocate a new handle block and to save/restore the last | |
| 63 // Java fp/sp. A pointer to the JavaCallWrapper is stored on the stack. | |
| 64 | |
| 65 class JavaCallWrapper: StackObj { | |
| 66 friend class VMStructs; | |
| 67 private: | |
| 68 JavaThread* _thread; // the thread to which this call belongs | |
| 69 JNIHandleBlock* _handles; // the saved handle block | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
70 Method* _callee_method; // to be able to collect arguments if entry frame is top frame |
| 0 | 71 oop _receiver; // the receiver of the call (if a non-static call) |
| 72 | |
| 73 JavaFrameAnchor _anchor; // last thread anchor state that we must restore | |
| 74 | |
| 75 JavaValue* _result; // result value | |
| 76 | |
| 77 public: | |
| 78 // Construction/destruction | |
| 79 JavaCallWrapper(methodHandle callee_method, Handle receiver, JavaValue* result, TRAPS); | |
| 80 ~JavaCallWrapper(); | |
| 81 | |
| 82 // Accessors | |
| 83 JavaThread* thread() const { return _thread; } | |
| 84 JNIHandleBlock* handles() const { return _handles; } | |
| 85 | |
| 86 JavaFrameAnchor* anchor(void) { return &_anchor; } | |
| 87 | |
| 88 JavaValue* result() const { return _result; } | |
| 89 // GC support | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
3960
diff
changeset
|
90 Method* callee_method() { return _callee_method; } |
| 0 | 91 oop receiver() { return _receiver; } |
| 92 void oops_do(OopClosure* f); | |
| 93 | |
| 94 }; | |
| 95 | |
| 96 | |
| 97 // Encapsulates arguments to a JavaCall (faster, safer, and more convenient than using var-args) | |
| 98 class JavaCallArguments : public StackObj { | |
| 99 private: | |
| 100 enum Constants { | |
| 101 _default_size = 8 // Must be at least # of arguments in JavaCalls methods | |
| 102 }; | |
| 103 | |
| 104 intptr_t _value_buffer [_default_size + 1]; | |
| 105 bool _is_oop_buffer[_default_size + 1]; | |
| 106 | |
| 107 intptr_t* _value; | |
| 108 bool* _is_oop; | |
| 109 int _size; | |
| 110 int _max_size; | |
| 111 bool _start_at_zero; // Support late setting of receiver | |
| 112 | |
| 113 void initialize() { | |
| 114 // Starts at first element to support set_receiver. | |
| 115 _value = &_value_buffer[1]; | |
| 116 _is_oop = &_is_oop_buffer[1]; | |
| 117 | |
| 118 _max_size = _default_size; | |
| 119 _size = 0; | |
| 120 _start_at_zero = false; | |
| 121 } | |
| 122 | |
| 123 public: | |
| 124 JavaCallArguments() { initialize(); } | |
| 125 | |
| 126 JavaCallArguments(Handle receiver) { | |
| 127 initialize(); | |
| 128 push_oop(receiver); | |
| 129 } | |
| 130 | |
| 131 JavaCallArguments(int max_size) { | |
| 132 if (max_size > _default_size) { | |
| 133 _value = NEW_RESOURCE_ARRAY(intptr_t, max_size + 1); | |
| 134 _is_oop = NEW_RESOURCE_ARRAY(bool, max_size + 1); | |
| 1506 | 135 |
| 0 | 136 // Reserve room for potential receiver in value and is_oop |
| 137 _value++; _is_oop++; | |
| 1506 | 138 |
| 0 | 139 _max_size = max_size; |
| 140 _size = 0; | |
| 141 _start_at_zero = false; | |
| 142 } else { | |
| 143 initialize(); | |
| 144 } | |
| 145 } | |
| 146 | |
| 147 inline void push_oop(Handle h) { _is_oop[_size] = true; | |
| 148 JNITypes::put_obj((oop)h.raw_value(), _value, _size); } | |
| 149 | |
| 150 inline void push_int(int i) { _is_oop[_size] = false; | |
| 151 JNITypes::put_int(i, _value, _size); } | |
| 152 | |
| 153 inline void push_double(double d) { _is_oop[_size] = false; _is_oop[_size + 1] = false; | |
| 154 JNITypes::put_double(d, _value, _size); } | |
| 155 | |
| 156 inline void push_long(jlong l) { _is_oop[_size] = false; _is_oop[_size + 1] = false; | |
| 157 JNITypes::put_long(l, _value, _size); } | |
| 158 | |
| 159 inline void push_float(float f) { _is_oop[_size] = false; | |
| 160 JNITypes::put_float(f, _value, _size); } | |
| 161 | |
| 162 // receiver | |
| 163 Handle receiver() { | |
| 164 assert(_size > 0, "must at least be one argument"); | |
| 165 assert(_is_oop[0], "first argument must be an oop"); | |
| 166 assert(_value[0] != 0, "receiver must be not-null"); | |
| 167 return Handle((oop*)_value[0], false); | |
| 168 } | |
| 169 | |
| 170 void set_receiver(Handle h) { | |
| 171 assert(_start_at_zero == false, "can only be called once"); | |
| 172 _start_at_zero = true; | |
| 173 _is_oop--; | |
| 174 _value--; | |
| 175 _size++; | |
| 176 _is_oop[0] = true; | |
| 177 _value[0] = (intptr_t)h.raw_value(); | |
| 178 } | |
| 179 | |
| 180 // Converts all Handles to oops, and returns a reference to parameter vector | |
| 181 intptr_t* parameters() ; | |
| 182 int size_of_parameters() const { return _size; } | |
| 183 | |
| 184 // Verify that pushed arguments fits a given method | |
|
465
dc16daa0329d
6739363: Xcheck jni doesn't check native function arguments
poonam
parents:
0
diff
changeset
|
185 void verify(methodHandle method, BasicType return_type, Thread *thread); |
| 0 | 186 }; |
| 187 | |
| 188 // All calls to Java have to go via JavaCalls. Sets up the stack frame | |
| 189 // and makes sure that the last_Java_frame pointers are chained correctly. | |
| 190 // | |
| 191 | |
| 192 class JavaCalls: AllStatic { | |
| 193 static void call_helper(JavaValue* result, methodHandle* method, JavaCallArguments* args, TRAPS); | |
| 194 public: | |
| 195 // Optimized Constuctor call | |
| 196 static void call_default_constructor(JavaThread* thread, methodHandle method, Handle receiver, TRAPS); | |
| 197 | |
| 198 // call_special | |
| 199 // ------------ | |
| 200 // The receiver must be first oop in argument list | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
201 static void call_special(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS); |
| 0 | 202 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
203 static void call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS); // No args |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
204 static void call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
205 static void call_special(JavaValue* result, Handle receiver, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS); |
| 0 | 206 |
| 207 // virtual call | |
| 208 // ------------ | |
| 209 | |
| 210 // The receiver must be first oop in argument list | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
211 static void call_virtual(JavaValue* result, KlassHandle spec_klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS); |
| 0 | 212 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
213 static void call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, TRAPS); // No args |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
214 static void call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
215 static void call_virtual(JavaValue* result, Handle receiver, KlassHandle spec_klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS); |
| 0 | 216 |
| 217 // Static call | |
| 218 // ----------- | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
219 static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, JavaCallArguments* args, TRAPS); |
| 0 | 220 |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
221 static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
222 static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, TRAPS); |
|
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1972
diff
changeset
|
223 static void call_static(JavaValue* result, KlassHandle klass, Symbol* name, Symbol* signature, Handle arg1, Handle arg2, TRAPS); |
| 0 | 224 |
| 225 // Low-level interface | |
| 226 static void call(JavaValue* result, methodHandle method, JavaCallArguments* args, TRAPS); | |
| 227 }; | |
| 1972 | 228 |
| 229 #endif // SHARE_VM_RUNTIME_JAVACALLS_HPP |