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