1 /*
2 * Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
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 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include <jni.h>
26 #include "libproc.h"
27
28 #include <elf.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <fcntl.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <limits.h>
35
36 #if defined(x86_64) && !defined(amd64)
37 #define amd64 1
38 #endif
39
40 #ifdef i386
41 #include "sun_jvm_hotspot_debugger_x86_X86ThreadContext.h"
42 #endif
43
44 #ifdef amd64
45 #include "sun_jvm_hotspot_debugger_amd64_AMD64ThreadContext.h"
46 #endif
47
48 #if defined(sparc) || defined(sparcv9)
49 #include "sun_jvm_hotspot_debugger_sparc_SPARCThreadContext.h"
50 #endif
51
52 #ifdef ppc64
53 #include "sun_jvm_hotspot_debugger_ppc64_PPC64ThreadContext.h"
54 #endif
55
56 static jfieldID p_ps_prochandle_ID = 0;
57 static jfieldID threadList_ID = 0;
58 static jfieldID loadObjectList_ID = 0;
59
60 static jmethodID createClosestSymbol_ID = 0;
61 static jmethodID createLoadObject_ID = 0;
62 static jmethodID getThreadForThreadId_ID = 0;
63 static jmethodID listAdd_ID = 0;
64
65 #define CHECK_EXCEPTION_(value) if ((*env)->ExceptionOccurred(env)) { return value; }
66 #define CHECK_EXCEPTION if ((*env)->ExceptionOccurred(env)) { return;}
67 #define THROW_NEW_DEBUGGER_EXCEPTION_(str, value) { throw_new_debugger_exception(env, str); return value; }
68 #define THROW_NEW_DEBUGGER_EXCEPTION(str) { throw_new_debugger_exception(env, str); return;}
69
70 void throw_new_debugger_exception(JNIEnv* env, const char* errMsg) {
71 jclass clazz;
72 clazz = (*env)->FindClass(env, "sun/jvm/hotspot/debugger/DebuggerException");
73 CHECK_EXCEPTION;
74 (*env)->ThrowNew(env, clazz, errMsg);
75 }
76
77 struct ps_prochandle* get_proc_handle(JNIEnv* env, jobject this_obj) {
78 jlong ptr = (*env)->GetLongField(env, this_obj, p_ps_prochandle_ID);
79 return (struct ps_prochandle*)(intptr_t)ptr;
80 }
81
82 /*
83 * Class: sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal
84 * Method: init0
85 * Signature: ()V
86 */
87 JNIEXPORT void JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_init0
88 (JNIEnv *env, jclass cls) {
89 jclass listClass;
90
91 if (init_libproc(getenv("LIBSAPROC_DEBUG") != NULL) != true) {
92 THROW_NEW_DEBUGGER_EXCEPTION("can't initialize libproc");
93 }
94
95 // fields we use
96 p_ps_prochandle_ID = (*env)->GetFieldID(env, cls, "p_ps_prochandle", "J");
97 CHECK_EXCEPTION;
98 threadList_ID = (*env)->GetFieldID(env, cls, "threadList", "Ljava/util/List;");
99 CHECK_EXCEPTION;
100 loadObjectList_ID = (*env)->GetFieldID(env, cls, "loadObjectList", "Ljava/util/List;");
101 CHECK_EXCEPTION;
102
103 // methods we use
104 createClosestSymbol_ID = (*env)->GetMethodID(env, cls, "createClosestSymbol",
105 "(Ljava/lang/String;J)Lsun/jvm/hotspot/debugger/cdbg/ClosestSymbol;");
106 CHECK_EXCEPTION;
107 createLoadObject_ID = (*env)->GetMethodID(env, cls, "createLoadObject",
108 "(Ljava/lang/String;JJ)Lsun/jvm/hotspot/debugger/cdbg/LoadObject;");
109 CHECK_EXCEPTION;
110 getThreadForThreadId_ID = (*env)->GetMethodID(env, cls, "getThreadForThreadId",
111 "(J)Lsun/jvm/hotspot/debugger/ThreadProxy;");
112 CHECK_EXCEPTION;
113 // java.util.List method we call
114 listClass = (*env)->FindClass(env, "java/util/List");
115 CHECK_EXCEPTION;
116 listAdd_ID = (*env)->GetMethodID(env, listClass, "add", "(Ljava/lang/Object;)Z");
117 CHECK_EXCEPTION;
118 }
119
120 JNIEXPORT jint JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_getAddressSize
121 (JNIEnv *env, jclass cls)
122 {
123 #ifdef _LP64
124 return 8;
125 #else
126 return 4;
127 #endif
128
129 }
130
131
132 static void fillThreadsAndLoadObjects(JNIEnv* env, jobject this_obj, struct ps_prochandle* ph) {
133 int n = 0, i = 0;
134
135 // add threads
136 n = get_num_threads(ph);
137 for (i = 0; i < n; i++) {
138 jobject thread;
139 jobject threadList;
140 lwpid_t lwpid;
141
142 lwpid = get_lwp_id(ph, i);
143 thread = (*env)->CallObjectMethod(env, this_obj, getThreadForThreadId_ID,
144 (jlong)lwpid);
145 CHECK_EXCEPTION;
146 threadList = (*env)->GetObjectField(env, this_obj, threadList_ID);
147 CHECK_EXCEPTION;
148 (*env)->CallBooleanMethod(env, threadList, listAdd_ID, thread);
149 CHECK_EXCEPTION;
150 }
151
152 // add load objects
153 n = get_num_libs(ph);
154 for (i = 0; i < n; i++) {
155 uintptr_t base;
156 const char* name;
157 jobject loadObject;
158 jobject loadObjectList;
159 jstring str;
160
161 base = get_lib_base(ph, i);
162 name = get_lib_name(ph, i);
163
164 str = (*env)->NewStringUTF(env, name);
165 CHECK_EXCEPTION;
166 loadObject = (*env)->CallObjectMethod(env, this_obj, createLoadObject_ID, str, (jlong)0, (jlong)base);
167 CHECK_EXCEPTION;
168 loadObjectList = (*env)->GetObjectField(env, this_obj, loadObjectList_ID);
169 CHECK_EXCEPTION;
170 (*env)->CallBooleanMethod(env, loadObjectList, listAdd_ID, loadObject);
171 CHECK_EXCEPTION;
172 }
173 }
174
175
176 /*
177 * Verify that a named ELF binary file (core or executable) has the same
178 * bitness as ourselves.
179 * Throw an exception if there is a mismatch or other problem.
180 *
181 * If we proceed using a mismatched debugger/debuggee, the best to hope
182 * for is a missing symbol, the worst is a crash searching for debug symbols.
183 */
184 void verifyBitness(JNIEnv *env, const char *binaryName) {
185 int fd = open(binaryName, O_RDONLY);
186 if (fd < 0) {
187 THROW_NEW_DEBUGGER_EXCEPTION("cannot open binary file");
188 }
189 unsigned char elf_ident[EI_NIDENT];
190 int i = read(fd, &elf_ident, sizeof(elf_ident));
191 close(fd);
192
193 if (i < 0) {
194 THROW_NEW_DEBUGGER_EXCEPTION("cannot read binary file");
195 }
196 #ifndef _LP64
197 if (elf_ident[EI_CLASS] == ELFCLASS64) {
198 THROW_NEW_DEBUGGER_EXCEPTION("debuggee is 64 bit, use 64-bit java for debugger");
199 }
200 #else
201 if (elf_ident[EI_CLASS] != ELFCLASS64) {
202 THROW_NEW_DEBUGGER_EXCEPTION("debuggee is 32 bit, use 32 bit java for debugger");
203 }
204 #endif
205 }
206
207
208 /*
209 * Class: sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal
210 * Method: attach0
211 * Signature: (I)V
212 */
213 JNIEXPORT void JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_attach0__I
214 (JNIEnv *env, jobject this_obj, jint jpid) {
215
216 // For bitness checking, locate binary at /proc/jpid/exe
217 char buf[PATH_MAX];
218 snprintf((char *) &buf, PATH_MAX, "/proc/%d/exe", jpid);
219 verifyBitness(env, (char *) &buf);
220 CHECK_EXCEPTION;
221
222 struct ps_prochandle* ph;
223 if ( (ph = Pgrab(jpid)) == NULL) {
224 THROW_NEW_DEBUGGER_EXCEPTION("Can't attach to the process");
225 }
226 (*env)->SetLongField(env, this_obj, p_ps_prochandle_ID, (jlong)(intptr_t)ph);
227 fillThreadsAndLoadObjects(env, this_obj, ph);
228 }
229
230 /*
231 * Class: sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal
232 * Method: attach0
233 * Signature: (Ljava/lang/String;Ljava/lang/String;)V
234 */
235 JNIEXPORT void JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_attach0__Ljava_lang_String_2Ljava_lang_String_2
236 (JNIEnv *env, jobject this_obj, jstring execName, jstring coreName) {
237 const char *execName_cstr;
238 const char *coreName_cstr;
239 jboolean isCopy;
240 struct ps_prochandle* ph;
241
242 execName_cstr = (*env)->GetStringUTFChars(env, execName, &isCopy);
243 CHECK_EXCEPTION;
244 coreName_cstr = (*env)->GetStringUTFChars(env, coreName, &isCopy);
245 CHECK_EXCEPTION;
246
247 verifyBitness(env, execName_cstr);
248 CHECK_EXCEPTION;
249
250 if ( (ph = Pgrab_core(execName_cstr, coreName_cstr)) == NULL) {
251 (*env)->ReleaseStringUTFChars(env, execName, execName_cstr);
252 (*env)->ReleaseStringUTFChars(env, coreName, coreName_cstr);
253 THROW_NEW_DEBUGGER_EXCEPTION("Can't attach to the core file");
254 }
255 (*env)->SetLongField(env, this_obj, p_ps_prochandle_ID, (jlong)(intptr_t)ph);
256 (*env)->ReleaseStringUTFChars(env, execName, execName_cstr);
257 (*env)->ReleaseStringUTFChars(env, coreName, coreName_cstr);
258 fillThreadsAndLoadObjects(env, this_obj, ph);
259 }
260
261 /*
262 * Class: sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal
263 * Method: detach0
264 * Signature: ()V
265 */
266 JNIEXPORT void JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_detach0
267 (JNIEnv *env, jobject this_obj) {
268 struct ps_prochandle* ph = get_proc_handle(env, this_obj);
269 if (ph != NULL) {
270 Prelease(ph);
271 }
272 }
273
274 /*
275 * Class: sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal
276 * Method: lookupByName0
277 * Signature: (Ljava/lang/String;Ljava/lang/String;)J
278 */
279 JNIEXPORT jlong JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_lookupByName0
280 (JNIEnv *env, jobject this_obj, jstring objectName, jstring symbolName) {
281 const char *objectName_cstr, *symbolName_cstr;
282 jlong addr;
283 jboolean isCopy;
284 struct ps_prochandle* ph = get_proc_handle(env, this_obj);
285
286 objectName_cstr = NULL;
287 if (objectName != NULL) {
288 objectName_cstr = (*env)->GetStringUTFChars(env, objectName, &isCopy);
289 CHECK_EXCEPTION_(0);
290 }
291 symbolName_cstr = (*env)->GetStringUTFChars(env, symbolName, &isCopy);
292 CHECK_EXCEPTION_(0);
293
294 addr = (jlong) lookup_symbol(ph, objectName_cstr, symbolName_cstr);
295
296 if (objectName_cstr != NULL) {
297 (*env)->ReleaseStringUTFChars(env, objectName, objectName_cstr);
298 }
299 (*env)->ReleaseStringUTFChars(env, symbolName, symbolName_cstr);
300 return addr;
301 }
302
303 /*
304 * Class: sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal
305 * Method: lookupByAddress0
306 * Signature: (J)Lsun/jvm/hotspot/debugger/cdbg/ClosestSymbol;
307 */
308 JNIEXPORT jobject JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_lookupByAddress0
309 (JNIEnv *env, jobject this_obj, jlong addr) {
310 uintptr_t offset;
311 jobject obj;
312 jstring str;
313 const char* sym = NULL;
314
315 struct ps_prochandle* ph = get_proc_handle(env, this_obj);
316 sym = symbol_for_pc(ph, (uintptr_t) addr, &offset);
317 if (sym == NULL) return 0;
318 str = (*env)->NewStringUTF(env, sym);
319 CHECK_EXCEPTION_(NULL);
320 obj = (*env)->CallObjectMethod(env, this_obj, createClosestSymbol_ID, str, (jlong)offset);
321 CHECK_EXCEPTION_(NULL);
322 return obj;
323 }
324
325 /*
326 * Class: sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal
327 * Method: readBytesFromProcess0
328 * Signature: (JJ)Lsun/jvm/hotspot/debugger/ReadResult;
329 */
330 JNIEXPORT jbyteArray JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_readBytesFromProcess0
331 (JNIEnv *env, jobject this_obj, jlong addr, jlong numBytes) {
332
333 jboolean isCopy;
334 jbyteArray array;
335 jbyte *bufPtr;
336 ps_err_e err;
337
338 array = (*env)->NewByteArray(env, numBytes);
339 CHECK_EXCEPTION_(0);
340 bufPtr = (*env)->GetByteArrayElements(env, array, &isCopy);
341 CHECK_EXCEPTION_(0);
342
343 err = ps_pdread(get_proc_handle(env, this_obj), (psaddr_t) (uintptr_t)addr, bufPtr, numBytes);
344 (*env)->ReleaseByteArrayElements(env, array, bufPtr, 0);
345 return (err == PS_OK)? array : 0;
346 }
347
348 #if defined(i386) || defined(amd64) || defined(sparc) || defined(sparcv9) | defined(ppc64) || defined(aarch64)
349 JNIEXPORT jlongArray JNICALL Java_sun_jvm_hotspot_debugger_linux_LinuxDebuggerLocal_getThreadIntegerRegisterSet0
350 (JNIEnv *env, jobject this_obj, jint lwp_id) {
351
352 struct user_regs_struct gregs;
353 jboolean isCopy;
354 jlongArray array;
355 jlong *regs;
356 int i;
357
358 struct ps_prochandle* ph = get_proc_handle(env, this_obj);
359 if (get_lwp_regs(ph, lwp_id, &gregs) != true) {
360 THROW_NEW_DEBUGGER_EXCEPTION_("get_thread_regs failed for a lwp", 0);
361 }
362
363 #undef NPRGREG
364 #ifdef i386
365 #define NPRGREG sun_jvm_hotspot_debugger_x86_X86ThreadContext_NPRGREG
366 #endif
367 #ifdef amd64
368 #define NPRGREG sun_jvm_hotspot_debugger_amd64_AMD64ThreadContext_NPRGREG
369 #endif
370 #ifdef aarch64
371 #define NPRGREG 32
372 #endif
373 #if defined(sparc) || defined(sparcv9)
374 #define NPRGREG sun_jvm_hotspot_debugger_sparc_SPARCThreadContext_NPRGREG
375 #endif
376 #ifdef ppc64
377 #define NPRGREG sun_jvm_hotspot_debugger_ppc64_PPC64ThreadContext_NPRGREG
378 #endif
379
380
381 array = (*env)->NewLongArray(env, NPRGREG);
382 CHECK_EXCEPTION_(0);
383 regs = (*env)->GetLongArrayElements(env, array, &isCopy);
384
385 #undef REG_INDEX
386
387 #ifdef i386
388 #define REG_INDEX(reg) sun_jvm_hotspot_debugger_x86_X86ThreadContext_##reg
389
390 regs[REG_INDEX(GS)] = (uintptr_t) gregs.xgs;
391 regs[REG_INDEX(FS)] = (uintptr_t) gregs.xfs;
392 regs[REG_INDEX(ES)] = (uintptr_t) gregs.xes;
393 regs[REG_INDEX(DS)] = (uintptr_t) gregs.xds;
394 regs[REG_INDEX(EDI)] = (uintptr_t) gregs.edi;
395 regs[REG_INDEX(ESI)] = (uintptr_t) gregs.esi;
396 regs[REG_INDEX(FP)] = (uintptr_t) gregs.ebp;
397 regs[REG_INDEX(SP)] = (uintptr_t) gregs.esp;
398 regs[REG_INDEX(EBX)] = (uintptr_t) gregs.ebx;
399 regs[REG_INDEX(EDX)] = (uintptr_t) gregs.edx;
400 regs[REG_INDEX(ECX)] = (uintptr_t) gregs.ecx;
401 regs[REG_INDEX(EAX)] = (uintptr_t) gregs.eax;
402 regs[REG_INDEX(PC)] = (uintptr_t) gregs.eip;
403 regs[REG_INDEX(CS)] = (uintptr_t) gregs.xcs;
404 regs[REG_INDEX(SS)] = (uintptr_t) gregs.xss;
405
406 #endif /* i386 */
407
408 #ifdef amd64
409 #define REG_INDEX(reg) sun_jvm_hotspot_debugger_amd64_AMD64ThreadContext_##reg
410
411 regs[REG_INDEX(R15)] = gregs.r15;
412 regs[REG_INDEX(R14)] = gregs.r14;
413 regs[REG_INDEX(R13)] = gregs.r13;
414 regs[REG_INDEX(R12)] = gregs.r12;
415 regs[REG_INDEX(RBP)] = gregs.rbp;
416 regs[REG_INDEX(RBX)] = gregs.rbx;
417 regs[REG_INDEX(R11)] = gregs.r11;
418 regs[REG_INDEX(R10)] = gregs.r10;
419 regs[REG_INDEX(R9)] = gregs.r9;
420 regs[REG_INDEX(R8)] = gregs.r8;
421 regs[REG_INDEX(RAX)] = gregs.rax;
422 regs[REG_INDEX(RCX)] = gregs.rcx;
423 regs[REG_INDEX(RDX)] = gregs.rdx;
424 regs[REG_INDEX(RSI)] = gregs.rsi;
425 regs[REG_INDEX(RDI)] = gregs.rdi;
426 regs[REG_INDEX(RIP)] = gregs.rip;
427 regs[REG_INDEX(CS)] = gregs.cs;
428 regs[REG_INDEX(RSP)] = gregs.rsp;
429 regs[REG_INDEX(SS)] = gregs.ss;
430 regs[REG_INDEX(FSBASE)] = gregs.fs_base;
431 regs[REG_INDEX(GSBASE)] = gregs.gs_base;
432 regs[REG_INDEX(DS)] = gregs.ds;
433 regs[REG_INDEX(ES)] = gregs.es;
434 regs[REG_INDEX(FS)] = gregs.fs;
435 regs[REG_INDEX(GS)] = gregs.gs;
436
437 #endif /* amd64 */
438
439 #if defined(sparc) || defined(sparcv9)
440
441 #define REG_INDEX(reg) sun_jvm_hotspot_debugger_sparc_SPARCThreadContext_##reg
442
443 #ifdef _LP64
444 regs[REG_INDEX(R_PSR)] = gregs.tstate;
445 regs[REG_INDEX(R_PC)] = gregs.tpc;
446 regs[REG_INDEX(R_nPC)] = gregs.tnpc;
447 regs[REG_INDEX(R_Y)] = gregs.y;
448 #else
449 regs[REG_INDEX(R_PSR)] = gregs.psr;
450 regs[REG_INDEX(R_PC)] = gregs.pc;
451 regs[REG_INDEX(R_nPC)] = gregs.npc;
452 regs[REG_INDEX(R_Y)] = gregs.y;
453 #endif
454 regs[REG_INDEX(R_G0)] = 0 ;
455 regs[REG_INDEX(R_G1)] = gregs.u_regs[0];
456 regs[REG_INDEX(R_G2)] = gregs.u_regs[1];
457 regs[REG_INDEX(R_G3)] = gregs.u_regs[2];
458 regs[REG_INDEX(R_G4)] = gregs.u_regs[3];
459 regs[REG_INDEX(R_G5)] = gregs.u_regs[4];
460 regs[REG_INDEX(R_G6)] = gregs.u_regs[5];
461 regs[REG_INDEX(R_G7)] = gregs.u_regs[6];
462 regs[REG_INDEX(R_O0)] = gregs.u_regs[7];
463 regs[REG_INDEX(R_O1)] = gregs.u_regs[8];
464 regs[REG_INDEX(R_O2)] = gregs.u_regs[ 9];
465 regs[REG_INDEX(R_O3)] = gregs.u_regs[10];
466 regs[REG_INDEX(R_O4)] = gregs.u_regs[11];
467 regs[REG_INDEX(R_O5)] = gregs.u_regs[12];
468 regs[REG_INDEX(R_O6)] = gregs.u_regs[13];
469 regs[REG_INDEX(R_O7)] = gregs.u_regs[14];
470 #endif /* sparc */
471
472 #if defined(aarch64)
473
474 #define REG_INDEX(reg) sun_jvm_hotspot_debugger_aarch64_AARCH64ThreadContext_##reg
475
476 #endif /* aarch64 */
477
478 #ifdef ppc64
479 #define REG_INDEX(reg) sun_jvm_hotspot_debugger_ppc64_PPC64ThreadContext_##reg
480
481 regs[REG_INDEX(LR)] = gregs.link;
482 regs[REG_INDEX(NIP)] = gregs.nip;
483 regs[REG_INDEX(R0)] = gregs.gpr[0];
484 regs[REG_INDEX(R1)] = gregs.gpr[1];
485 regs[REG_INDEX(R2)] = gregs.gpr[2];
486 regs[REG_INDEX(R3)] = gregs.gpr[3];
487 regs[REG_INDEX(R4)] = gregs.gpr[4];
488 regs[REG_INDEX(R5)] = gregs.gpr[5];
489 regs[REG_INDEX(R6)] = gregs.gpr[6];
490 regs[REG_INDEX(R7)] = gregs.gpr[7];
491 regs[REG_INDEX(R8)] = gregs.gpr[8];
492 regs[REG_INDEX(R9)] = gregs.gpr[9];
493 regs[REG_INDEX(R10)] = gregs.gpr[10];
494 regs[REG_INDEX(R11)] = gregs.gpr[11];
495 regs[REG_INDEX(R12)] = gregs.gpr[12];
496 regs[REG_INDEX(R13)] = gregs.gpr[13];
497 regs[REG_INDEX(R14)] = gregs.gpr[14];
498 regs[REG_INDEX(R15)] = gregs.gpr[15];
499 regs[REG_INDEX(R16)] = gregs.gpr[16];
500 regs[REG_INDEX(R17)] = gregs.gpr[17];
501 regs[REG_INDEX(R18)] = gregs.gpr[18];
502 regs[REG_INDEX(R19)] = gregs.gpr[19];
503 regs[REG_INDEX(R20)] = gregs.gpr[20];
504 regs[REG_INDEX(R21)] = gregs.gpr[21];
505 regs[REG_INDEX(R22)] = gregs.gpr[22];
506 regs[REG_INDEX(R23)] = gregs.gpr[23];
507 regs[REG_INDEX(R24)] = gregs.gpr[24];
508 regs[REG_INDEX(R25)] = gregs.gpr[25];
509 regs[REG_INDEX(R26)] = gregs.gpr[26];
510 regs[REG_INDEX(R27)] = gregs.gpr[27];
511 regs[REG_INDEX(R28)] = gregs.gpr[28];
512 regs[REG_INDEX(R29)] = gregs.gpr[29];
513 regs[REG_INDEX(R30)] = gregs.gpr[30];
514 regs[REG_INDEX(R31)] = gregs.gpr[31];
515
516 #endif
517
518 (*env)->ReleaseLongArrayElements(env, array, regs, JNI_COMMIT);
519 return array;
520 }
521 #endif