diff -u -r ./hotspot/src_/share/vm/prims/jvmtiEnv.cpp ./hotspot/src/share/vm/pri - Pastebin.com (original) (raw)

1. diff -u -r ./hotspot/src_/share/vm/prims/jvmtiEnv.cpp ./hotspot/src/share/vm/prims/jvmtiEnv.cpp
2. --- ./hotspot/src_/share/vm/prims/jvmtiEnv.cpp 2013-12-19 01:10:36.297992000 +0100
3. +++ ./hotspot/src/share/vm/prims/jvmtiEnv.cpp 2014-02-10 14:52:14.734339000 +0100
4. @@ -1982,6 +1982,106 @@
5. //
6. + // Operand Stack functions
7. + //
9. +// Threads_lock NOT held, java_thread not protected by lock
10. +// java_thread - pre-checked
11. +// java_thread - unchecked
12. +// depth - pre-checked as non-negative
13. +// value_ptr - pre-checked for NULL
14. +jvmtiError
15. +JvmtiEnv::GetOperandObject(JavaThread* java_thread, jint depth, jint slot, jobject* value_ptr) {
16. + JavaThread* current_thread = JavaThread::current();
17. + // rm object is created to clean up the javaVFrame created in
18. + // doit_prologue(), but after doit() is finished with it.
19. + ResourceMark rm(current_thread);
21. + VM_GetOperand op(java_thread, current_thread, depth, slot);
22. + VMThread::execute(&op);
23. + jvmtiError err = op.result();
24. + if (err != JVMTI_ERROR_NONE) {
25. + return err;
26. + } else {
27. + *value_ptr = op.value().l;
28. + return JVMTI_ERROR_NONE;
29. + }
30. +} /* end GetOperandObject */
33. +// Threads_lock NOT held, java_thread not protected by lock
34. +// java_thread - pre-checked
35. +// java_thread - unchecked
36. +// depth - pre-checked as non-negative
37. +// value_ptr - pre-checked for NULL
38. +jvmtiError
39. +JvmtiEnv::GetOperandInt(JavaThread* java_thread, jint depth, jint slot, jint* value_ptr) {
40. + // rm object is created to clean up the javaVFrame created in
41. + // doit_prologue(), but after doit() is finished with it.
42. + ResourceMark rm;
44. + VM_GetOperand op(java_thread, depth, slot, T_INT);
45. + VMThread::execute(&op);
46. + *value_ptr = op.value().i;
47. + return op.result();
48. +} /* end GetOperandInt */
51. +// Threads_lock NOT held, java_thread not protected by lock
52. +// java_thread - pre-checked
53. +// java_thread - unchecked
54. +// depth - pre-checked as non-negative
55. +// value_ptr - pre-checked for NULL
56. +jvmtiError
57. +JvmtiEnv::GetOperandLong(JavaThread* java_thread, jint depth, jint slot, jlong* value_ptr) {
58. + // rm object is created to clean up the javaVFrame created in
59. + // doit_prologue(), but after doit() is finished with it.
60. + ResourceMark rm;
62. + VM_GetOperand op(java_thread, depth, slot, T_LONG);
63. + VMThread::execute(&op);
64. + *value_ptr = op.value().j;
65. + return op.result();
66. +} /* end GetOperandLong */
69. +// Threads_lock NOT held, java_thread not protected by lock
70. +// java_thread - pre-checked
71. +// java_thread - unchecked
72. +// depth - pre-checked as non-negative
73. +// value_ptr - pre-checked for NULL
74. +jvmtiError
75. +JvmtiEnv::GetOperandFloat(JavaThread* java_thread, jint depth, jint slot, jfloat* value_ptr) {
76. + // rm object is created to clean up the javaVFrame created in
77. + // doit_prologue(), but after doit() is finished with it.
78. + ResourceMark rm;
80. + VM_GetOperand op(java_thread, depth, slot, T_FLOAT);
81. + VMThread::execute(&op);
82. + *value_ptr = op.value().f;
83. + return op.result();
84. +} /* end GetOperandFloat */
87. +// Threads_lock NOT held, java_thread not protected by lock
88. +// java_thread - pre-checked
89. +// java_thread - unchecked
90. +// depth - pre-checked as non-negative
91. +// value_ptr - pre-checked for NULL
92. +jvmtiError
93. +JvmtiEnv::GetOperandDouble(JavaThread* java_thread, jint depth, jint slot, jdouble* value_ptr) {
94. + // rm object is created to clean up the javaVFrame created in
95. + // doit_prologue(), but after doit() is finished with it.
96. + ResourceMark rm;
98. + VM_GetOperand op(java_thread, depth, slot, T_DOUBLE);
99. + VMThread::execute(&op);
100. + *value_ptr = op.value().d;
101. + return op.result();
102. +} /* end GetOperandDouble */
105. + //
106. // Breakpoint functions
107. //
108. diff -u -r ./hotspot/src_/share/vm/prims/jvmtiImpl.cpp ./hotspot/src/share/vm/prims/jvmtiImpl.cpp
109. --- ./hotspot/src_/share/vm/prims/jvmtiImpl.cpp 2013-12-19 01:10:36.309992000 +0100
110. +++ ./hotspot/src/share/vm/prims/jvmtiImpl.cpp 2014-02-10 14:57:14.350344000 +0100
111. @@ -827,6 +827,147 @@
112. JavaThread* thread, JavaThread* caller_thread, jint depth)
113. : VM_GetOrSetLocal(thread, caller_thread, depth, 0) {}
115. +///////////////////////////////////////////////////////////////
116. +//
117. +// class VM_GetOperand
118. +//
120. +// Constructor for non-object getter
121. +VM_GetOperand::VM_GetOperand(JavaThread* thread, jint depth, int index, BasicType type)
122. + : _thread(thread)
123. + , _calling_thread(NULL)
124. + , _depth(depth)
125. + , _index(index)
126. + , _type(type)
127. + , _jvf(NULL)
128. + , _result(JVMTI_ERROR_NONE)
129. +{
130. +}
132. +// Constructor for object getter
133. +VM_GetOperand::VM_GetOperand(JavaThread* thread, JavaThread* calling_thread, jint depth, int index)
134. + : _thread(thread)
135. + , _calling_thread(calling_thread)
136. + , _depth(depth)
137. + , _index(index)
138. + , _type(T_OBJECT)
139. + , _jvf(NULL)
140. + , _result(JVMTI_ERROR_NONE)
141. +{
142. +}
144. +vframe *VM_GetOperand::get_vframe() {
145. + if (!_thread->has_last_Java_frame()) {
146. + return NULL;
147. + }
148. + RegisterMap reg_map(_thread);
149. + vframe *vf = _thread->last_java_vframe(&reg_map);
150. + int d = 0;
151. + while ((vf != NULL) && (d < _depth)) {
152. + vf = vf->java_sender();
153. + d++;
154. + }
155. + return vf;
156. +}
158. +javaVFrame *VM_GetOperand::get_java_vframe() {
159. + vframe* vf = get_vframe();
160. + if (vf == NULL) {
161. + _result = JVMTI_ERROR_NO_MORE_FRAMES;
162. + return NULL;
163. + }
164. + javaVFrame *jvf = (javaVFrame*)vf;
166. + if (!vf->is_java_frame()) {
167. + _result = JVMTI_ERROR_OPAQUE_FRAME;
168. + return NULL;
169. + }
170. + return jvf;
171. +}
173. +// Checks error conditions:
174. +// JVMTI_ERROR_INVALID_SLOT
175. +// Returns: 'true' - everything is Ok, 'false' - error code
176. +bool VM_GetOperand::check_slot_type(javaVFrame* jvf) {
177. + // index checking
178. + StackValueCollection *expressions = _jvf->expressions();
179. + jint size = expressions->size();
180. + size -= (_type == T_LONG || _type == T_DOUBLE) ? 1 : 0;
181. +
182. + if (_index < 0 || _index >= size) {
183. + _result = JVMTI_ERROR_INVALID_SLOT;
184. + return false;
185. + }
186. +
187. + // FIXME insert proper type-checking code here
188. +
189. + return true;
190. +}
192. +bool VM_GetOperand::doit_prologue() {
193. + _jvf = get_java_vframe();
194. + NULL_CHECK(_jvf, false);
196. + if (_jvf->method()->is_native()) {
197. + if (getting_receiver() && !_jvf->method()->is_static()) {
198. + return true;
199. + } else {
200. + _result = JVMTI_ERROR_OPAQUE_FRAME;
201. + return false;
202. + }
203. + }
205. + if (!check_slot_type(_jvf)) {
206. + return false;
207. + }
208. + return true;
209. +}
211. +void VM_GetOperand::doit() {
212. + // get
213. + if (_jvf->method()->is_native() && _jvf->is_compiled_frame()) {
214. + assert(getting_receiver(), "Can only get here when getting receiver");
215. + oop receiver = _jvf->fr().get_native_receiver();
216. + _value.l = JNIHandles::make_local(_calling_thread, receiver);
217. + } else {
218. + StackValueCollection *expressions = _jvf->expressions();
220. + if (expressions->at(_index)->type() == T_CONFLICT) {
221. + memset(&_value, 0, sizeof(_value));
222. + _value.l = NULL;
223. + return;
224. + }
226. + switch (_type) {
227. + case T_INT: _value.i = expressions->int_at (_index); break;
228. + case T_LONG: _value.j = expressions->long_at (_index); break;
229. + case T_FLOAT: _value.f = expressions->float_at (_index); break;
230. + case T_DOUBLE: _value.d = expressions->double_at(_index); break;
231. + case T_OBJECT: {
232. + // Wrap the oop to be returned in a local JNI handle since
233. + // oops_do() no longer applies after doit() is finished.
234. + intptr_t temp = expressions->at(_index)->get_int();
235. + intptr_t *addr = &temp;
236. + _value.l = JNIHandles::make_local(_calling_thread, *(oop *)addr);
237. + break;
238. + }
239. + default: ShouldNotReachHere();
240. + }
241. + }
242. +}
245. +bool VM_GetOperand::allow_nested_vm_operations() const {
246. + return true; // May need to deoptimize
247. +}
250. +VM_GetOperandReceiver::VM_GetOperandReceiver(
251. + JavaThread* thread, JavaThread* caller_thread, jint depth)
252. + : VM_GetOperand(thread, caller_thread, depth, 0) {}
255. /////////////////////////////////////////////////////////////////////////////////////////
256. //
257. diff -u -r ./hotspot/src_/share/vm/prims/jvmtiImpl.hpp ./hotspot/src/share/vm/prims/jvmtiImpl.hpp
258. --- ./hotspot/src_/share/vm/prims/jvmtiImpl.hpp 2013-12-19 01:10:36.309992000 +0100
259. +++ ./hotspot/src/share/vm/prims/jvmtiImpl.hpp 2014-02-10 14:54:03.762341000 +0100
260. @@ -400,6 +400,58 @@
261. ///////////////////////////////////////////////////////////////
262. +// This is a copy of VM_GetOrSetLocal modified to access operands
263. +// instead of local variables.
264. +//
265. +class VM_GetOperand : public VM_Operation {
266. + protected:
267. + JavaThread* _thread;
268. + JavaThread* _calling_thread;
269. + jint _depth;
270. + jint _index;
271. + BasicType _type;
272. + jvalue _value;
273. + javaVFrame* _jvf;
275. + // It is possible to get the receiver out of a non-static native wrapper
276. + // frame. Use VM_GetReceiver to do this.
277. + virtual bool getting_receiver() const { return false; }
279. + jvmtiError _result;
281. + vframe* get_vframe();
282. + javaVFrame* get_java_vframe();
283. + bool check_slot_type(javaVFrame* vf);
285. +public:
286. + // Constructor for non-object getter
287. + VM_GetOperand(JavaThread* thread, jint depth, jint index, BasicType type);
289. + // Constructor for object getter
290. + VM_GetOperand(JavaThread* thread, JavaThread* calling_thread, jint depth,
291. + int index);
293. + VMOp_Type type() const { return VMOp_GetOperand; }
294. + jvalue value() { return _value; }
295. + jvmtiError result() { return _result; }
297. + bool doit_prologue();
298. + void doit();
299. + bool allow_nested_vm_operations() const;
300. + const char* name() const { return "get operands"; }
301. +};
303. +class VM_GetOperandReceiver : public VM_GetOperand {
304. + protected:
305. + virtual bool getting_receiver() const { return true; }
307. + public:
308. + VM_GetOperandReceiver(JavaThread* thread, JavaThread* calling_thread, jint depth);
309. + const char* name() const { return "get operand receiver"; }
310. +};
313. +///////////////////////////////////////////////////////////////
314. //
315. // class JvmtiSuspendControl
316. //
317. diff -u -r ./hotspot/src_/share/vm/prims/jvmti.xml ./hotspot/src/share/vm/prims/jvmti.xml
318. --- ./hotspot/src_/share/vm/prims/jvmti.xml 2013-12-19 01:10:36.293992000 +0100
319. +++ ./hotspot/src/share/vm/prims/jvmti.xml 2014-02-10 14:50:31.750337000 +0100
320. @@ -6137,6 +6137,266 @@
324. +
325. +
327. +
328. + These functions are used to retrieve or set the value of an operand stack slot.
329. + The slot is identified by the depth of the frame containing its
330. + value and the slot's number within that frame.
331. +
332. +
333. +
334. + Get Operand Stack Value - Object
335. +
336. + This function can be used to retrieve the value of an operand
337. + stack slot whose type is Object or a subclass of Object.
338. +
339. + jvmdi
340. +
341. +
342. +
343. +
344. +
345. +
346. +
347. + The thread of the frame containing the slot's value.
348. +
349. +
350. +
351. +
352. +
353. + The depth of the frame containing the slot's value.
354. +
355. +
356. +
357. +
358. +
359. + The slot's number.
360. +
361. +
362. +
363. +
364. +
365. + On return, points to the slot's value.
366. +
367. +
368. +
369. +
370. +
371. + Invalid slot.
372. +
373. +
374. + The slot's type is not
375. + Object or a subclass of Object.
376. +
377. +
378. + Not a visible frame
379. +
380. +
381. +
382. +
383. +
384. + Get Operand Stack Value - Int
385. +
386. + This function can be used to retrieve the value of an operand
387. + stack slot whose type is int,
388. + short, char, byte, or
389. + boolean.
390. +
391. + jvmdi
392. +
393. +
394. +
395. +
396. +
397. +
398. +
399. + The thread of the frame containing the slot's value.
400. +
401. +
402. +
403. +
404. +
405. + The depth of the frame containing the slot's value.
406. +
407. +
408. +
409. +
410. +
411. + The slot's number.
412. +
413. +
414. +
415. +
416. +
417. + On return, points to the slot's value.
418. +
419. +
420. +
421. +
422. +
423. + Invalid slot.
424. +
425. +
426. + The slot's type is not
427. + int, short,
428. + char, byte, or
429. + boolean.
430. +
431. +
432. + Not a visible frame
433. +
434. +
435. +
436. +
437. +
438. + Get Operand Stack Value - Long
439. +
440. + This function can be used to retrieve the value of an operand
441. + stack slot whose type is long.
442. +
443. + jvmdi
444. +
445. +
446. +
447. +
448. +
449. +
450. +
451. + The thread of the frame containing the slot's value.
452. +
453. +
454. +
455. +
456. +
457. + The depth of the frame containing the slot's value.
458. +
459. +
460. +
461. +
462. +
463. + The slot's number.
464. +
465. +
466. +
467. +
468. +
469. + On return, points to the slot's value.
470. +
471. +
472. +
473. +
474. +
475. + Invalid slot.
476. +
477. +
478. + The variable type is not long.
479. +
480. +
481. + Not a visible frame
482. +
483. +
484. +
485. +
486. +
487. + Get Operand Stack Value - Float
488. +
489. + This function can be used to retrieve the value of an operand
490. + stack slot whose type is float.
491. +
492. + jvmdi
493. +
494. +
495. +
496. +
497. +
498. +
499. +
500. + The thread of the frame containing the slot's value.
501. +
502. +
503. +
504. +
505. +
506. + The depth of the frame containing the slot's value.
507. +
508. +
509. +
510. +
511. +
512. + The slot's number.
513. +
514. +
515. +
516. +
517. +
518. + On return, points to the slot's value.
519. +
520. +
521. +
522. +
523. +
524. + Invalid slot.
525. +
526. +
527. + The variable type is not float.
528. +
529. +
530. + Not a visible frame
531. +
532. +
533. +
534. +
535. +
536. + Get Operand Stack Value - Double
537. +
538. + This function can be used to retrieve the value of an operand
539. + stack slot whose type is double.
540. +
541. + jvmdi
542. +
543. +
544. +
545. +
546. +
547. +
548. +
549. + The thread of the frame containing the slot's value.
550. +
551. +
552. +
553. +
554. +
555. + The depth of the frame containing the slot's value.
556. +
557. +
558. +
559. +
560. +
561. + The slot's number.
562. +
563. +
564. +
565. +
566. +
567. + On return, points to the slot's value.
568. +
569. +
570. +
571. +
572. +
573. + Invalid slot.
574. +
575. +
576. + The variable type is not double.
577. +
578. +
579. + Not a visible frame
580. +
581. +
582. +
583. +
585. diff -u -r ./hotspot/src_/share/vm/runtime/vm_operations.hpp ./hotspot/src/share/vm/runtime/vm_operations.hpp
586. --- ./hotspot/src_/share/vm/runtime/vm_operations.hpp 2013-12-19 01:10:36.377992000 +0100
587. +++ ./hotspot/src/share/vm/runtime/vm_operations.hpp 2014-02-10 14:48:02.346335000 +0100
588. @@ -87,6 +87,7 @@
589. template(GetFrameLocation) \
590. template(ChangeBreakpoints) \
591. template(GetOrSetLocal) \
592. + template(GetOperand) \
593. template(GetCurrentLocation) \
594. template(EnterInterpOnlyMode) \
595. template(ChangeSingleStep) \