Mercurial > hg > truffle
annotate src/share/vm/interpreter/bytecodeInterpreter.hpp @ 20543:e7d0505c8a30
8059758: Footprint regressions with JDK-8038423
Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything.
Reviewed-by: jwilhelm, brutisso
| author | tschatzl |
|---|---|
| date | Fri, 10 Oct 2014 15:51:58 +0200 |
| parents | bfd9d884693d |
| children | 4ca6dc0799b6 |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
2 * Copyright (c) 2002, 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:
1509
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1509
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:
1509
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #ifndef SHARE_VM_INTERPRETER_BYTECODEINTERPRETER_HPP |
| 26 #define SHARE_VM_INTERPRETER_BYTECODEINTERPRETER_HPP | |
| 27 | |
| 28 #include "memory/allocation.hpp" | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
29 #include "oops/methodData.hpp" |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
30 #include "oops/method.hpp" |
| 1972 | 31 #include "runtime/basicLock.hpp" |
| 32 #include "runtime/frame.hpp" | |
| 33 #include "runtime/globals.hpp" | |
| 34 #include "utilities/globalDefinitions.hpp" | |
| 35 #ifdef TARGET_ARCH_x86 | |
| 36 # include "bytes_x86.hpp" | |
| 37 #endif | |
| 38 #ifdef TARGET_ARCH_sparc | |
| 39 # include "bytes_sparc.hpp" | |
| 40 #endif | |
| 41 #ifdef TARGET_ARCH_zero | |
| 42 # include "bytes_zero.hpp" | |
| 43 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
44 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
45 # include "bytes_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
46 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
47 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
48 # include "bytes_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
49 #endif |
| 1972 | 50 |
| 0 | 51 #ifdef CC_INTERP |
| 52 | |
| 6926 | 53 // JavaStack Implementation |
| 54 #define MORE_STACK(count) \ | |
| 55 (topOfStack -= ((count) * Interpreter::stackElementWords)) | |
| 56 | |
| 0 | 57 // CVM definitions find hotspot equivalents... |
| 58 | |
| 59 union VMJavaVal64 { | |
| 60 jlong l; | |
| 61 jdouble d; | |
| 62 uint32_t v[2]; | |
| 63 }; | |
| 64 | |
| 65 | |
| 66 typedef class BytecodeInterpreter* interpreterState; | |
| 67 | |
| 68 struct call_message { | |
|
14400
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
69 class Method* _callee; // method to call during call_method request |
|
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
70 address _callee_entry_point; // address to jump to for call_method request |
|
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
71 int _bcp_advance; // size of the invoke bytecode operation |
| 0 | 72 }; |
| 73 | |
| 74 struct osr_message { | |
|
14400
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
75 address _osr_buf; // the osr buffer |
|
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
76 address _osr_entry; // the entry to the osr method |
| 0 | 77 }; |
| 78 | |
| 79 struct osr_result { | |
|
14400
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
80 nmethod* nm; // osr nmethod |
|
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
81 address return_addr; // osr blob return address |
| 0 | 82 }; |
| 83 | |
| 84 // Result returned to frame manager | |
| 85 union frame_manager_message { | |
|
14400
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
86 call_message _to_call; // describes callee |
|
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
87 osr_message _osr; // describes the osr |
|
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
88 osr_result _osr_result; // result of OSR request |
| 0 | 89 }; |
| 90 | |
| 91 class BytecodeInterpreter : StackObj { | |
| 92 friend class SharedRuntime; | |
| 93 friend class AbstractInterpreterGenerator; | |
| 94 friend class CppInterpreterGenerator; | |
| 95 friend class InterpreterGenerator; | |
| 96 friend class InterpreterMacroAssembler; | |
| 97 friend class frame; | |
| 98 friend class VMStructs; | |
| 99 | |
| 100 public: | |
| 101 enum messages { | |
| 102 no_request = 0, // unused | |
| 103 initialize, // Perform one time interpreter initializations (assumes all switches set) | |
| 104 // status message to C++ interpreter | |
| 105 method_entry, // initial method entry to interpreter | |
| 106 method_resume, // frame manager response to return_from_method request (assuming a frame to resume) | |
| 107 deopt_resume, // returning from a native call into a deopted frame | |
| 108 deopt_resume2, // deopt resume as a result of a PopFrame | |
| 109 got_monitors, // frame manager response to more_monitors request | |
| 110 rethrow_exception, // unwinding and throwing exception | |
| 111 // requests to frame manager from C++ interpreter | |
| 112 call_method, // request for new frame from interpreter, manager responds with method_entry | |
| 113 return_from_method, // request from interpreter to unwind, manager responds with method_continue | |
| 114 more_monitors, // need a new monitor | |
| 115 throwing_exception, // unwind stack and rethrow | |
| 116 popping_frame, // unwind call and retry call | |
|
14400
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
117 do_osr, // request this invocation be OSR's |
|
bfd9d884693d
8019519: PPC64 (part 105): C interpreter: implement support for jvmti early return.
goetz
parents:
6926
diff
changeset
|
118 early_return // early return as commanded by jvmti |
| 0 | 119 }; |
| 120 | |
| 121 private: | |
| 122 JavaThread* _thread; // the vm's java thread pointer | |
| 123 address _bcp; // instruction pointer | |
| 124 intptr_t* _locals; // local variable pointer | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
125 ConstantPoolCache* _constants; // constant pool cache |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
126 Method* _method; // method being executed |
| 0 | 127 DataLayout* _mdx; // compiler profiling data for current bytecode |
| 128 intptr_t* _stack; // expression stack | |
| 129 messages _msg; // frame manager <-> interpreter message | |
| 130 frame_manager_message _result; // result to frame manager | |
| 131 interpreterState _prev_link; // previous interpreter state | |
| 132 oop _oop_temp; // mirror for interpreted native, null otherwise | |
| 133 intptr_t* _stack_base; // base of expression stack | |
| 134 intptr_t* _stack_limit; // limit of expression stack | |
| 135 BasicObjectLock* _monitor_base; // base of monitors on the native stack | |
| 136 | |
| 137 | |
| 138 public: | |
| 139 // Constructor is only used by the initialization step. All other instances are created | |
| 140 // by the frame manager. | |
| 141 BytecodeInterpreter(messages msg); | |
| 142 | |
| 143 // | |
| 144 // Deoptimization support | |
| 145 // | |
| 146 static void layout_interpreterState(interpreterState to_fill, | |
| 147 frame* caller, | |
| 148 frame* interpreter_frame, | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
149 Method* method, |
| 0 | 150 intptr_t* locals, |
| 151 intptr_t* stack, | |
| 152 intptr_t* stack_base, | |
| 153 intptr_t* monitor_base, | |
| 154 intptr_t* frame_bottom, | |
| 155 bool top_frame); | |
| 156 | |
| 157 /* | |
| 158 * Generic 32-bit wide "Java slot" definition. This type occurs | |
| 159 * in operand stacks, Java locals, object fields, constant pools. | |
| 160 */ | |
| 161 union VMJavaVal32 { | |
| 162 jint i; | |
| 163 jfloat f; | |
| 164 class oopDesc* r; | |
| 165 uint32_t raw; | |
| 166 }; | |
| 167 | |
| 168 /* | |
| 169 * Generic 64-bit Java value definition | |
| 170 */ | |
| 171 union VMJavaVal64 { | |
| 172 jlong l; | |
| 173 jdouble d; | |
| 174 uint32_t v[2]; | |
| 175 }; | |
| 176 | |
| 177 /* | |
| 178 * Generic 32-bit wide "Java slot" definition. This type occurs | |
| 179 * in Java locals, object fields, constant pools, and | |
| 180 * operand stacks (as a CVMStackVal32). | |
| 181 */ | |
| 182 typedef union VMSlotVal32 { | |
| 183 VMJavaVal32 j; /* For "Java" values */ | |
| 184 address a; /* a return created by jsr or jsr_w */ | |
| 185 } VMSlotVal32; | |
| 186 | |
| 187 | |
| 188 /* | |
| 189 * Generic 32-bit wide stack slot definition. | |
| 190 */ | |
| 191 union VMStackVal32 { | |
| 192 VMJavaVal32 j; /* For "Java" values */ | |
| 193 VMSlotVal32 s; /* any value from a "slot" or locals[] */ | |
| 194 }; | |
| 195 | |
| 196 inline JavaThread* thread() { return _thread; } | |
| 197 | |
| 198 inline address bcp() { return _bcp; } | |
| 199 inline void set_bcp(address new_bcp) { _bcp = new_bcp; } | |
| 200 | |
| 201 inline intptr_t* locals() { return _locals; } | |
| 202 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
203 inline ConstantPoolCache* constants() { return _constants; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
204 inline Method* method() { return _method; } |
| 0 | 205 inline DataLayout* mdx() { return _mdx; } |
| 206 inline void set_mdx(DataLayout *new_mdx) { _mdx = new_mdx; } | |
| 207 | |
| 208 inline messages msg() { return _msg; } | |
| 209 inline void set_msg(messages new_msg) { _msg = new_msg; } | |
| 210 | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
211 inline Method* callee() { return _result._to_call._callee; } |
|
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
2480
diff
changeset
|
212 inline void set_callee(Method* new_callee) { _result._to_call._callee = new_callee; } |
| 0 | 213 inline void set_callee_entry_point(address entry) { _result._to_call._callee_entry_point = entry; } |
| 214 inline void set_osr_buf(address buf) { _result._osr._osr_buf = buf; } | |
| 215 inline void set_osr_entry(address entry) { _result._osr._osr_entry = entry; } | |
| 216 inline int bcp_advance() { return _result._to_call._bcp_advance; } | |
| 217 inline void set_bcp_advance(int count) { _result._to_call._bcp_advance = count; } | |
| 218 | |
| 219 inline interpreterState prev() { return _prev_link; } | |
| 220 | |
| 221 inline intptr_t* stack() { return _stack; } | |
| 222 inline void set_stack(intptr_t* new_stack) { _stack = new_stack; } | |
| 223 | |
| 224 | |
| 225 inline intptr_t* stack_base() { return _stack_base; } | |
| 226 inline intptr_t* stack_limit() { return _stack_limit; } | |
| 227 | |
| 228 inline BasicObjectLock* monitor_base() { return _monitor_base; } | |
| 229 | |
| 230 /* | |
| 231 * 64-bit Arithmetic: | |
| 232 * | |
| 233 * The functions below follow the semantics of the | |
| 234 * ladd, land, ldiv, lmul, lor, lxor, and lrem bytecodes, | |
| 235 * respectively. | |
| 236 */ | |
| 237 | |
| 238 static jlong VMlongAdd(jlong op1, jlong op2); | |
| 239 static jlong VMlongAnd(jlong op1, jlong op2); | |
| 240 static jlong VMlongDiv(jlong op1, jlong op2); | |
| 241 static jlong VMlongMul(jlong op1, jlong op2); | |
| 242 static jlong VMlongOr (jlong op1, jlong op2); | |
| 243 static jlong VMlongSub(jlong op1, jlong op2); | |
| 244 static jlong VMlongXor(jlong op1, jlong op2); | |
| 245 static jlong VMlongRem(jlong op1, jlong op2); | |
| 246 | |
| 247 /* | |
| 248 * Shift: | |
| 249 * | |
| 250 * The functions below follow the semantics of the | |
| 251 * lushr, lshl, and lshr bytecodes, respectively. | |
| 252 */ | |
| 253 | |
| 254 static jlong VMlongUshr(jlong op1, jint op2); | |
| 255 static jlong VMlongShl (jlong op1, jint op2); | |
| 256 static jlong VMlongShr (jlong op1, jint op2); | |
| 257 | |
| 258 /* | |
| 259 * Unary: | |
| 260 * | |
| 261 * Return the negation of "op" (-op), according to | |
| 262 * the semantics of the lneg bytecode. | |
| 263 */ | |
| 264 | |
| 265 static jlong VMlongNeg(jlong op); | |
| 266 | |
| 267 /* | |
| 268 * Return the complement of "op" (~op) | |
| 269 */ | |
| 270 | |
| 271 static jlong VMlongNot(jlong op); | |
| 272 | |
| 273 | |
| 274 /* | |
| 275 * Comparisons to 0: | |
| 276 */ | |
| 277 | |
| 278 static int32_t VMlongLtz(jlong op); /* op <= 0 */ | |
| 279 static int32_t VMlongGez(jlong op); /* op >= 0 */ | |
| 280 static int32_t VMlongEqz(jlong op); /* op == 0 */ | |
| 281 | |
| 282 /* | |
| 283 * Between operands: | |
| 284 */ | |
| 285 | |
| 286 static int32_t VMlongEq(jlong op1, jlong op2); /* op1 == op2 */ | |
| 287 static int32_t VMlongNe(jlong op1, jlong op2); /* op1 != op2 */ | |
| 288 static int32_t VMlongGe(jlong op1, jlong op2); /* op1 >= op2 */ | |
| 289 static int32_t VMlongLe(jlong op1, jlong op2); /* op1 <= op2 */ | |
| 290 static int32_t VMlongLt(jlong op1, jlong op2); /* op1 < op2 */ | |
| 291 static int32_t VMlongGt(jlong op1, jlong op2); /* op1 > op2 */ | |
| 292 | |
| 293 /* | |
| 294 * Comparisons (returning an jint value: 0, 1, or -1) | |
| 295 * | |
| 296 * Between operands: | |
| 297 * | |
| 298 * Compare "op1" and "op2" according to the semantics of the | |
| 299 * "lcmp" bytecode. | |
| 300 */ | |
| 301 | |
| 302 static int32_t VMlongCompare(jlong op1, jlong op2); | |
| 303 | |
| 304 /* | |
| 305 * Convert int to long, according to "i2l" bytecode semantics | |
| 306 */ | |
| 307 static jlong VMint2Long(jint val); | |
| 308 | |
| 309 /* | |
| 310 * Convert long to int, according to "l2i" bytecode semantics | |
| 311 */ | |
| 312 static jint VMlong2Int(jlong val); | |
| 313 | |
| 314 /* | |
| 315 * Convert long to float, according to "l2f" bytecode semantics | |
| 316 */ | |
| 317 static jfloat VMlong2Float(jlong val); | |
| 318 | |
| 319 /* | |
| 320 * Convert long to double, according to "l2d" bytecode semantics | |
| 321 */ | |
| 322 static jdouble VMlong2Double(jlong val); | |
| 323 | |
| 324 /* | |
| 325 * Java floating-point float value manipulation. | |
| 326 * | |
| 327 * The result argument is, once again, an lvalue. | |
| 328 * | |
| 329 * Arithmetic: | |
| 330 * | |
| 331 * The functions below follow the semantics of the | |
| 332 * fadd, fsub, fmul, fdiv, and frem bytecodes, | |
| 333 * respectively. | |
| 334 */ | |
| 335 | |
| 336 static jfloat VMfloatAdd(jfloat op1, jfloat op2); | |
| 337 static jfloat VMfloatSub(jfloat op1, jfloat op2); | |
| 338 static jfloat VMfloatMul(jfloat op1, jfloat op2); | |
| 339 static jfloat VMfloatDiv(jfloat op1, jfloat op2); | |
| 340 static jfloat VMfloatRem(jfloat op1, jfloat op2); | |
| 341 | |
| 342 /* | |
| 343 * Unary: | |
| 344 * | |
| 345 * Return the negation of "op" (-op), according to | |
| 346 * the semantics of the fneg bytecode. | |
| 347 */ | |
| 348 | |
| 349 static jfloat VMfloatNeg(jfloat op); | |
| 350 | |
| 351 /* | |
| 352 * Comparisons (returning an int value: 0, 1, or -1) | |
| 353 * | |
| 354 * Between operands: | |
| 355 * | |
| 356 * Compare "op1" and "op2" according to the semantics of the | |
| 357 * "fcmpl" (direction is -1) or "fcmpg" (direction is 1) bytecodes. | |
| 358 */ | |
| 359 | |
| 360 static int32_t VMfloatCompare(jfloat op1, jfloat op2, | |
| 361 int32_t direction); | |
| 362 /* | |
| 363 * Conversion: | |
| 364 */ | |
| 365 | |
| 366 /* | |
| 367 * Convert float to double, according to "f2d" bytecode semantics | |
| 368 */ | |
| 369 | |
| 370 static jdouble VMfloat2Double(jfloat op); | |
| 371 | |
| 372 /* | |
| 373 ****************************************** | |
| 374 * Java double floating-point manipulation. | |
| 375 ****************************************** | |
| 376 * | |
| 377 * The result argument is, once again, an lvalue. | |
| 378 * | |
| 379 * Conversions: | |
| 380 */ | |
| 381 | |
| 382 /* | |
| 383 * Convert double to int, according to "d2i" bytecode semantics | |
| 384 */ | |
| 385 | |
| 386 static jint VMdouble2Int(jdouble val); | |
| 387 | |
| 388 /* | |
| 389 * Convert double to float, according to "d2f" bytecode semantics | |
| 390 */ | |
| 391 | |
| 392 static jfloat VMdouble2Float(jdouble val); | |
| 393 | |
| 394 /* | |
| 395 * Convert int to double, according to "i2d" bytecode semantics | |
| 396 */ | |
| 397 | |
| 398 static jdouble VMint2Double(jint val); | |
| 399 | |
| 400 /* | |
| 401 * Arithmetic: | |
| 402 * | |
| 403 * The functions below follow the semantics of the | |
| 404 * dadd, dsub, ddiv, dmul, and drem bytecodes, respectively. | |
| 405 */ | |
| 406 | |
| 407 static jdouble VMdoubleAdd(jdouble op1, jdouble op2); | |
| 408 static jdouble VMdoubleSub(jdouble op1, jdouble op2); | |
| 409 static jdouble VMdoubleDiv(jdouble op1, jdouble op2); | |
| 410 static jdouble VMdoubleMul(jdouble op1, jdouble op2); | |
| 411 static jdouble VMdoubleRem(jdouble op1, jdouble op2); | |
| 412 | |
| 413 /* | |
| 414 * Unary: | |
| 415 * | |
| 416 * Return the negation of "op" (-op), according to | |
| 417 * the semantics of the dneg bytecode. | |
| 418 */ | |
| 419 | |
| 420 static jdouble VMdoubleNeg(jdouble op); | |
| 421 | |
| 422 /* | |
| 423 * Comparisons (returning an int32_t value: 0, 1, or -1) | |
| 424 * | |
| 425 * Between operands: | |
| 426 * | |
| 427 * Compare "op1" and "op2" according to the semantics of the | |
| 428 * "dcmpl" (direction is -1) or "dcmpg" (direction is 1) bytecodes. | |
| 429 */ | |
| 430 | |
| 431 static int32_t VMdoubleCompare(jdouble op1, jdouble op2, int32_t direction); | |
| 432 | |
| 433 /* | |
| 434 * Copy two typeless 32-bit words from one location to another. | |
| 435 * This is semantically equivalent to: | |
| 436 * | |
| 437 * to[0] = from[0]; | |
| 438 * to[1] = from[1]; | |
| 439 * | |
| 440 * but this interface is provided for those platforms that could | |
| 441 * optimize this into a single 64-bit transfer. | |
| 442 */ | |
| 443 | |
| 444 static void VMmemCopy64(uint32_t to[2], const uint32_t from[2]); | |
| 445 | |
| 446 | |
| 447 // Arithmetic operations | |
| 448 | |
| 449 /* | |
| 450 * Java arithmetic methods. | |
| 451 * The functions below follow the semantics of the | |
| 452 * iadd, isub, imul, idiv, irem, iand, ior, ixor, | |
| 453 * and ineg bytecodes, respectively. | |
| 454 */ | |
| 455 | |
| 456 static jint VMintAdd(jint op1, jint op2); | |
| 457 static jint VMintSub(jint op1, jint op2); | |
| 458 static jint VMintMul(jint op1, jint op2); | |
| 459 static jint VMintDiv(jint op1, jint op2); | |
| 460 static jint VMintRem(jint op1, jint op2); | |
| 461 static jint VMintAnd(jint op1, jint op2); | |
| 462 static jint VMintOr (jint op1, jint op2); | |
| 463 static jint VMintXor(jint op1, jint op2); | |
| 464 | |
| 465 /* | |
| 466 * Shift Operation: | |
| 467 * The functions below follow the semantics of the | |
| 468 * iushr, ishl, and ishr bytecodes, respectively. | |
| 469 */ | |
| 470 | |
|
1681
126ea7725993
6953477: Increase portability and flexibility of building Hotspot
bobv
parents:
1552
diff
changeset
|
471 static juint VMintUshr(jint op, jint num); |
| 0 | 472 static jint VMintShl (jint op, jint num); |
| 473 static jint VMintShr (jint op, jint num); | |
| 474 | |
| 475 /* | |
| 476 * Unary Operation: | |
| 477 * | |
| 478 * Return the negation of "op" (-op), according to | |
| 479 * the semantics of the ineg bytecode. | |
| 480 */ | |
| 481 | |
| 482 static jint VMintNeg(jint op); | |
| 483 | |
| 484 /* | |
| 485 * Int Conversions: | |
| 486 */ | |
| 487 | |
| 488 /* | |
| 489 * Convert int to float, according to "i2f" bytecode semantics | |
| 490 */ | |
| 491 | |
| 492 static jfloat VMint2Float(jint val); | |
| 493 | |
| 494 /* | |
| 495 * Convert int to byte, according to "i2b" bytecode semantics | |
| 496 */ | |
| 497 | |
| 498 static jbyte VMint2Byte(jint val); | |
| 499 | |
| 500 /* | |
| 501 * Convert int to char, according to "i2c" bytecode semantics | |
| 502 */ | |
| 503 | |
| 504 static jchar VMint2Char(jint val); | |
| 505 | |
| 506 /* | |
| 507 * Convert int to short, according to "i2s" bytecode semantics | |
| 508 */ | |
| 509 | |
| 510 static jshort VMint2Short(jint val); | |
| 511 | |
| 512 /*========================================================================= | |
| 513 * Bytecode interpreter operations | |
| 514 *=======================================================================*/ | |
| 515 | |
| 516 static void dup(intptr_t *tos); | |
| 517 static void dup2(intptr_t *tos); | |
| 518 static void dup_x1(intptr_t *tos); /* insert top word two down */ | |
| 519 static void dup_x2(intptr_t *tos); /* insert top word three down */ | |
| 520 static void dup2_x1(intptr_t *tos); /* insert top 2 slots three down */ | |
| 521 static void dup2_x2(intptr_t *tos); /* insert top 2 slots four down */ | |
| 522 static void swap(intptr_t *tos); /* swap top two elements */ | |
| 523 | |
| 524 // umm don't like this method modifies its object | |
| 525 | |
| 526 // The Interpreter used when | |
| 527 static void run(interpreterState istate); | |
| 528 // The interpreter used if JVMTI needs interpreter events | |
| 529 static void runWithChecks(interpreterState istate); | |
| 530 static void End_Of_Interpreter(void); | |
| 531 | |
| 532 // Inline static functions for Java Stack and Local manipulation | |
| 533 | |
| 534 static address stack_slot(intptr_t *tos, int offset); | |
| 535 static jint stack_int(intptr_t *tos, int offset); | |
| 536 static jfloat stack_float(intptr_t *tos, int offset); | |
| 537 static oop stack_object(intptr_t *tos, int offset); | |
| 538 static jdouble stack_double(intptr_t *tos, int offset); | |
| 539 static jlong stack_long(intptr_t *tos, int offset); | |
| 540 | |
| 541 // only used for value types | |
| 542 static void set_stack_slot(intptr_t *tos, address value, int offset); | |
| 543 static void set_stack_int(intptr_t *tos, int value, int offset); | |
| 544 static void set_stack_float(intptr_t *tos, jfloat value, int offset); | |
| 545 static void set_stack_object(intptr_t *tos, oop value, int offset); | |
| 546 | |
| 547 // needs to be platform dep for the 32 bit platforms. | |
| 548 static void set_stack_double(intptr_t *tos, jdouble value, int offset); | |
| 549 static void set_stack_long(intptr_t *tos, jlong value, int offset); | |
| 550 | |
| 551 static void set_stack_double_from_addr(intptr_t *tos, address addr, int offset); | |
| 552 static void set_stack_long_from_addr(intptr_t *tos, address addr, int offset); | |
| 553 | |
| 554 // Locals | |
| 555 | |
| 556 static address locals_slot(intptr_t* locals, int offset); | |
| 557 static jint locals_int(intptr_t* locals, int offset); | |
| 558 static jfloat locals_float(intptr_t* locals, int offset); | |
| 559 static oop locals_object(intptr_t* locals, int offset); | |
| 560 static jdouble locals_double(intptr_t* locals, int offset); | |
| 561 static jlong locals_long(intptr_t* locals, int offset); | |
| 562 | |
| 563 static address locals_long_at(intptr_t* locals, int offset); | |
| 564 static address locals_double_at(intptr_t* locals, int offset); | |
| 565 | |
| 566 static void set_locals_slot(intptr_t *locals, address value, int offset); | |
| 567 static void set_locals_int(intptr_t *locals, jint value, int offset); | |
| 568 static void set_locals_float(intptr_t *locals, jfloat value, int offset); | |
| 569 static void set_locals_object(intptr_t *locals, oop value, int offset); | |
| 570 static void set_locals_double(intptr_t *locals, jdouble value, int offset); | |
| 571 static void set_locals_long(intptr_t *locals, jlong value, int offset); | |
| 572 static void set_locals_double_from_addr(intptr_t *locals, | |
| 573 address addr, int offset); | |
| 574 static void set_locals_long_from_addr(intptr_t *locals, | |
| 575 address addr, int offset); | |
| 576 | |
| 577 static void astore(intptr_t* topOfStack, int stack_offset, | |
| 578 intptr_t* locals, int locals_offset); | |
| 579 | |
| 580 // Support for dup and swap | |
| 581 static void copy_stack_slot(intptr_t *tos, int from_offset, int to_offset); | |
| 582 | |
| 583 #ifndef PRODUCT | |
| 584 static const char* C_msg(BytecodeInterpreter::messages msg); | |
| 585 void print(); | |
| 586 #endif // PRODUCT | |
| 587 | |
| 588 // Platform fields/methods | |
| 1972 | 589 #ifdef TARGET_ARCH_x86 |
| 590 # include "bytecodeInterpreter_x86.hpp" | |
| 591 #endif | |
| 592 #ifdef TARGET_ARCH_sparc | |
| 593 # include "bytecodeInterpreter_sparc.hpp" | |
| 594 #endif | |
| 595 #ifdef TARGET_ARCH_zero | |
| 596 # include "bytecodeInterpreter_zero.hpp" | |
| 597 #endif | |
|
2192
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
598 #ifdef TARGET_ARCH_arm |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
599 # include "bytecodeInterpreter_arm.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
600 #endif |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
601 #ifdef TARGET_ARCH_ppc |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
602 # include "bytecodeInterpreter_ppc.hpp" |
|
b92c45f2bc75
7016023: Enable building ARM and PPC from src/closed repository
bobv
parents:
1972
diff
changeset
|
603 #endif |
| 1972 | 604 |
| 0 | 605 |
| 606 }; // BytecodeInterpreter | |
| 607 | |
| 608 #endif // CC_INTERP | |
| 1972 | 609 |
| 610 #endif // SHARE_VM_INTERPRETER_BYTECODEINTERPRETER_HPP |