projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
regen config
[binutils-gdb.git] / gprofng / libcollector / unwind.c
1 /* Copyright (C) 2021-2023 Free Software Foundation, Inc.
2 Contributed by Oracle.
3
4 This file is part of GNU Binutils.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "config.h"
22 #include <alloca.h>
23 #include <dlfcn.h>
24 #include <stdlib.h>
25 #include <signal.h>
26 #include <unistd.h>
27 #include <pthread.h>
28
29 #include "gp-defs.h"
30 #include "collector.h"
31 #include "gp-experiment.h"
32 #include "memmgr.h"
33 #include "tsd.h"
34
35 /* Get dynamic module interface*/
36 #include "collector_module.h"
37
38 /* Get definitions for SP_LEAF_CHECK_MARKER, SP_TRUNC_STACK_MARKER */
39 #include "data_pckts.h"
40
41 #if ARCH(SPARC)
42 struct frame
43 {
44 long fr_local[8]; /* saved locals */
45 long fr_arg[6]; /* saved arguments [0 - 5] */
46 struct frame *fr_savfp; /* saved frame pointer */
47 long fr_savpc; /* saved program counter */
48 #if WSIZE(32)
49 char *fr_stret; /* struct return addr */
50 #endif
51 long fr_argd[6]; /* arg dump area */
52 long fr_argx[1]; /* array of args past the sixth */
53 };
54
55 #elif ARCH(Intel)
56 struct frame
57 {
58 unsigned long fr_savfp;
59 unsigned long fr_savpc;
60 };
61 #endif
62
63 /* Set the debug trace level */
64 #define DBG_LT0 0
65 #define DBG_LT1 1
66 #define DBG_LT2 2
67 #define DBG_LT3 3
68
69 int (*__collector_VM_ReadByteInstruction)(unsigned char *) = NULL;
70 #define VM_NO_ACCESS (-1)
71 #define VM_NOT_VM_MEMORY (-2)
72 #define VM_NOT_X_SEGMENT (-3)
73
74 #define isInside(p, bgn, end) ((p) >= (bgn) && (p) < (end))
75
76 /*
77 * Weed through all the arch dependent stuff to get the right definition
78 * for 'pc' in the ucontext structure. The system header files are mess
79 * dealing with all the arch (just look for PC, R_PC, REG_PC).
80 *
81 */
82
83 #if ARCH(SPARC)
84
85 #define IN_BARRIER(x) \
86 ( barrier_hdl && \
87 (unsigned long)x >= barrier_hdl && \
88 (unsigned long)x < barrier_hdlx )
89 static unsigned long barrier_hdl = 0;
90 static unsigned long barrier_hdlx = 0;
91
92 #if WSIZE(64)
93 #define STACK_BIAS 2047
94 #define IN_TRAP_HANDLER(x) \
95 ( misalign_hdl && \
96 (unsigned long)x >= misalign_hdl && \
97 (unsigned long)x < misalign_hdlx )
98 static unsigned long misalign_hdl = 0;
99 static unsigned long misalign_hdlx = 0;
100 #elif WSIZE(32)
101 #define STACK_BIAS 0
102 #endif
103
104 #if WSIZE(64)
105 #define GET_GREG(ctx,reg) (((ucontext_t*)ctx)->uc_mcontext.mc_gregs[(reg)])
106 #define GET_SP(ctx) (((ucontext_t*)ctx)->uc_mcontext.mc_gregs[MC_O6])
107 #define GET_PC(ctx) (((ucontext_t*)ctx)->uc_mcontext.mc_gregs[MC_PC])
108 #else
109 #define GET_GREG(ctx,reg) (((ucontext_t*)ctx)->uc_mcontext.gregs[(reg)])
110 #define GET_SP(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_O6])
111 #define GET_PC(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_PC])
112 #endif
113
114 #elif ARCH(Intel)
115 #include "opcodes/disassemble.h"
116
117 static int
118 fprintf_func (void *arg ATTRIBUTE_UNUSED, const char *fmt ATTRIBUTE_UNUSED, ...)
119 {
120 return 0;
121 }
122
123 static int
124 fprintf_styled_func (void *arg ATTRIBUTE_UNUSED,
125 enum disassembler_style st ATTRIBUTE_UNUSED,
126 const char *fmt ATTRIBUTE_UNUSED, ...)
127 {
128 return 0;
129 }
130
131 /* Get LENGTH bytes from info's buffer, at target address memaddr.
132 Transfer them to myaddr. */
133 static int
134 read_memory_func (bfd_vma memaddr, bfd_byte *myaddr, unsigned int length,
135 disassemble_info *info)
136 {
137 unsigned int opb = info->octets_per_byte;
138 size_t end_addr_offset = length / opb;
139 size_t max_addr_offset = info->buffer_length / opb;
140 size_t octets = (memaddr - info->buffer_vma) * opb;
141 if (memaddr < info->buffer_vma
142 || memaddr - info->buffer_vma > max_addr_offset
143 || memaddr - info->buffer_vma + end_addr_offset > max_addr_offset
144 || (info->stop_vma && (memaddr >= info->stop_vma
145 || memaddr + end_addr_offset > info->stop_vma)))
146 return -1;
147 memcpy (myaddr, info->buffer + octets, length);
148 return 0;
149 }
150
151 static void
152 print_address_func (bfd_vma addr ATTRIBUTE_UNUSED,
153 disassemble_info *info ATTRIBUTE_UNUSED) { }
154
155 static asymbol *
156 symbol_at_address_func (bfd_vma addr ATTRIBUTE_UNUSED,
157 disassemble_info *info ATTRIBUTE_UNUSED)
158 {
159 return NULL;
160 }
161
162 static bfd_boolean
163 symbol_is_valid (asymbol *sym ATTRIBUTE_UNUSED,
164 disassemble_info *info ATTRIBUTE_UNUSED)
165 {
166 return TRUE;
167 }
168
169 static void
170 memory_error_func (int status ATTRIBUTE_UNUSED, bfd_vma addr ATTRIBUTE_UNUSED,
171 disassemble_info *info ATTRIBUTE_UNUSED) { }
172
173
174 #if WSIZE(32)
175 #define GET_PC(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_EIP])
176 #define GET_SP(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_ESP])
177 #define GET_FP(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_EBP])
178
179 #elif WSIZE(64)
180 #define GET_PC(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_RIP])
181 #define GET_SP(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_RSP])
182 #define GET_FP(ctx) (((ucontext_t*)ctx)->uc_mcontext.gregs[REG_RBP])
183 #endif /* WSIZE() */
184
185 #elif ARCH(Aarch64)
186 #define GET_PC(ctx) (((ucontext_t*)ctx)->uc_mcontext.regs[15])
187 #define GET_SP(ctx) (((ucontext_t*)ctx)->uc_mcontext.regs[13])
188 #define GET_FP(ctx) (((ucontext_t*)ctx)->uc_mcontext.regs[14])
189 #endif /* ARCH() */
190
191 /*
192 * FILL_CONTEXT() for all platforms
193 * Could use getcontext() except:
194 * - it's not guaranteed to be async signal safe
195 * - it's a system call and not that lightweight
196 * - it's not portable as of POSIX.1-2008
197 * So we just use low-level mechanisms to fill in the few fields we need.
198 */
199 #if ARCH(SPARC)
200 #if WSIZE(32)
201 #define FILL_CONTEXT(context) \
202 { \
203 greg_t fp; \
204 __asm__ __volatile__( "mov %%i6, %0" : "=r" (fp) ); \
205 __asm__ __volatile__( "ta 3" ); \
206 GET_SP(context) = fp; \
207 GET_PC(context) = (greg_t)0; \
208 }
209
210 #elif WSIZE(64)
211 #define FILL_CONTEXT(context) \
212 { \
213 greg_t fp; \
214 __asm__ __volatile__( "mov %%i6, %0" : "=r" (fp) ); \
215 __asm__ __volatile__( "flushw" ); \
216 GET_SP(context) = fp; \
217 GET_PC(context) = (greg_t)0; \
218 }
219 #endif /* WSIZE() */
220
221 #elif ARCH(Intel)
222 #define FILL_CONTEXT(context) \
223 { \
224 context->uc_link = NULL; \
225 void *sp = __collector_getsp(); \
226 GET_SP(context) = (intptr_t)sp; \
227 GET_FP(context) = (intptr_t)__collector_getfp(); \
228 GET_PC(context) = (intptr_t)__collector_getpc(); \
229 context->uc_stack.ss_sp = sp; \
230 context->uc_stack.ss_size = 0x100000; \
231 }
232
233 #elif ARCH(Aarch64)
234 #define FILL_CONTEXT(context) \
235 { CALL_UTIL (getcontext) (context); \
236 context->uc_mcontext.sp = (__u64) __builtin_frame_address(0); \
237 }
238
239 #endif /* ARCH() */
240
241 static int
242 getByteInstruction (unsigned char *p)
243 {
244 if (__collector_VM_ReadByteInstruction)
245 {
246 int v = __collector_VM_ReadByteInstruction (p);
247 if (v != VM_NOT_VM_MEMORY)
248 return v;
249 }
250 return *p;
251 }
252
253 struct DataHandle *dhndl = NULL;
254
255 static unsigned unwind_key = COLLECTOR_TSD_INVALID_KEY;
256
257 /* To support two OpenMP API's we use a pointer
258 * to the actual function.
259 */
260 int (*__collector_omp_stack_trace)(char*, int, hrtime_t, void*) = NULL;
261 int (*__collector_mpi_stack_trace)(char*, int, hrtime_t) = NULL;
262
263 #define DEFAULT_MAX_NFRAMES 256
264 static int max_native_nframes = DEFAULT_MAX_NFRAMES;
265 static int max_java_nframes = DEFAULT_MAX_NFRAMES;
266
267 #define NATIVE_FRAME_BYTES(nframes) ( ((nframes)+1) * sizeof(long) )
268 #define JAVA_FRAME_BYTES(nframes) ( ((nframes)+1) * sizeof(long) * 2 + 16 )
269 #define OVERHEAD_BYTES ( 2 * sizeof(long) + 2 * sizeof(Stack_info) )
270
271 #define ROOT_UID 801425552975190205ULL
272 #define ROOT_UID_INV 92251691606677ULL
273 #define ROOT_IDX 13907816567264074199ULL
274 #define ROOT_IDX_INV 2075111ULL
275 #define UIDTableSize 1048576
276 static volatile uint64_t *UIDTable = NULL;
277 static volatile int seen_omp = 0;
278
279 static int stack_unwind (char *buf, int size, void *bptr, void *eptr, ucontext_t *context, int mode);
280 static FrameInfo compute_uid (Frame_packet *frp);
281 static int omp_no_walk = 0;
282
283 #if ARCH(Intel)
284 #define ValTableSize 1048576
285 #define OmpValTableSize 65536
286 static unsigned long *AddrTable_RA_FROMFP = NULL; // Cache for RA_FROMFP pcs
287 static unsigned long *AddrTable_RA_EOSTCK = NULL; // Cache for RA_EOSTCK pcs
288 static struct WalkContext *OmpCurCtxs = NULL;
289 static struct WalkContext *OmpCtxs = NULL;
290 static uint32_t *OmpVals = NULL;
291 static unsigned long *OmpRAs = NULL;
292 static unsigned long adjust_ret_addr (unsigned long ra, unsigned long segoff, unsigned long tend);
293 static int parse_x86_AVX_instruction (unsigned char *pc);
294
295 struct WalkContext
296 {
297 unsigned long pc;
298 unsigned long sp;
299 unsigned long fp;
300 unsigned long ln;
301 unsigned long sbase; /* stack boundary */
302 unsigned long tbgn; /* current memory segment start */
303 unsigned long tend; /* current memory segment end */
304 };
305 #endif
306
307 #if defined(DEBUG) && ARCH(Intel)
308 #include <execinfo.h>
309
310 static void
311 dump_stack (int nline)
312 {
313 if ((__collector_tracelevel & SP_DUMP_STACK) == 0)
314 return;
315
316 enum Constexpr { MAX_SIZE = 1024 };
317 void *array[MAX_SIZE];
318 size_t sz = backtrace (array, MAX_SIZE);
319 char **strings = backtrace_symbols (array, sz);
320 DprintfT (SP_DUMP_STACK, "\ndump_stack: %d size=%d\n", nline, (int) sz);
321 for (int i = 0; i < sz; i++)
322 DprintfT (SP_DUMP_STACK, " %3d: %p %s\n", i, array[i],
323 strings[i] ? strings[i] : "???");
324 }
325
326 #define dump_targets(nline, ntrg, targets) \
327 if ((__collector_tracelevel & SP_DUMP_UNWIND) != 0) \
328 for(int i = 0; i < ntrg; i++) \
329 DprintfT (SP_DUMP_UNWIND, " %2d: 0x%lx\n", i, (long) targets[i])
330 #else
331 #define dump_stack(x)
332 #define dump_targets(nline, ntrg, targets)
333 #endif
334
335 void
336 __collector_ext_unwind_key_init (int isPthread, void * stack)
337 {
338 void * ptr = __collector_tsd_get_by_key (unwind_key);
339 if (ptr == NULL)
340 {
341 TprintfT (DBG_LT2, "__collector_ext_unwind_key_init: cannot get tsd\n");
342 return;
343 }
344 if (isPthread)
345 {
346 size_t stack_size = 0;
347 void *stack_addr = 0;
348 pthread_t pthread = pthread_self ();
349 pthread_attr_t attr;
350 int err = pthread_getattr_np (pthread, &attr);
351 TprintfT (DBG_LT1, "__collector_ext_unwind_key_init: pthread: 0x%lx err: %d\n", pthread, err);
352 if (err == 0)
353 {
354 err = pthread_attr_getstack (&attr, &stack_addr, &stack_size);
355 if (err == 0)
356 stack_addr = (char*) stack_addr + stack_size;
357 TprintfT (DBG_LT1, "__collector_ext_unwind_key_init: stack_size=0x%lx eos=%p err=%d\n",
358 (long) stack_size, stack_addr, err);
359 err = pthread_attr_destroy (&attr);
360 TprintfT (DBG_LT1, "__collector_ext_unwind_key_init: destroy: %d\n", err);
361 }
362 *(void**) ptr = stack_addr;
363 }
364 else
365 *(void**) ptr = stack; // cloned thread
366 }
367
368 void
369 __collector_ext_unwind_init (int record)
370 {
371 int sz = UIDTableSize * sizeof (*UIDTable);
372 UIDTable = (uint64_t*) __collector_allocCSize (__collector_heap, sz, 1);
373 if (UIDTable == NULL)
374 {
375 __collector_terminate_expt ();
376 return;
377 }
378 CALL_UTIL (memset)((void*) UIDTable, 0, sz);
379
380 char *str = CALL_UTIL (getenv)("GPROFNG_JAVA_MAX_CALL_STACK_DEPTH");
381 if (str != NULL && *str != 0)
382 {
383 char *endptr;
384 int n = CALL_UTIL (strtol)(str, &endptr, 0);
385 if (endptr != str && n >= 0)
386 {
387 if (n < 5)
388 n = 5;
389 if (n > MAX_STACKDEPTH)
390 n = MAX_STACKDEPTH;
391 max_java_nframes = n;
392 }
393 }
394
395 str = CALL_UTIL (getenv)("GPROFNG_MAX_CALL_STACK_DEPTH");
396 if (str != NULL && *str != 0)
397 {
398 char *endptr = str;
399 int n = CALL_UTIL (strtol)(str, &endptr, 0);
400 if (endptr != str && n >= 0)
401 {
402 if (n < 5)
403 n = 5;
404 if (n > MAX_STACKDEPTH)
405 n = MAX_STACKDEPTH;
406 max_native_nframes = n;
407 }
408 }
409
410 TprintfT (DBG_LT0, "GPROFNG_MAX_CALL_STACK_DEPTH=%d GPROFNG_JAVA_MAX_CALL_STACK_DEPTH=%d\n",
411 max_native_nframes, max_java_nframes);
412 omp_no_walk = 1;
413
414 if (__collector_VM_ReadByteInstruction == NULL)
415 __collector_VM_ReadByteInstruction = (int(*)()) dlsym (RTLD_DEFAULT, "Async_VM_ReadByteInstruction");
416
417 #if ARCH(SPARC)
418 #if WSIZE(64)
419 misalign_hdl = (unsigned long) dlsym (RTLD_DEFAULT, "__misalign_trap_handler");
420 misalign_hdlx = (unsigned long) dlsym (RTLD_DEFAULT, "__misalign_trap_handler_end");
421 if (misalign_hdlx == 0)
422 misalign_hdlx = misalign_hdl + 292;
423 barrier_hdl = (unsigned long) dlsym (RTLD_DEFAULT, "__mt_EndOfTask_Barrier_");
424 barrier_hdlx = (unsigned long) dlsym (RTLD_DEFAULT, "__mt_EndOfTask_Barrier_Dummy_");
425 if (barrier_hdlx == 0)
426 barrier_hdl = 0;
427 #else
428 barrier_hdl = (unsigned long) dlsym (RTLD_DEFAULT, "__mt_EndOfTask_Barrier_");
429 barrier_hdlx = (unsigned long) dlsym (RTLD_DEFAULT, "__mt_EndOfTask_Barrier_Dummy_");
430 if (barrier_hdlx == 0)
431 barrier_hdl = 0;
432 #endif /* WSIZE() */
433
434 #elif ARCH(Intel)
435 sz = ValTableSize * sizeof (*AddrTable_RA_FROMFP);
436 AddrTable_RA_FROMFP = (unsigned long*) __collector_allocCSize (__collector_heap, sz, 1);
437 sz = ValTableSize * sizeof (*AddrTable_RA_EOSTCK);
438 AddrTable_RA_EOSTCK = (unsigned long*) __collector_allocCSize (__collector_heap, sz, 1);
439 if (omp_no_walk && (__collector_omp_stack_trace != NULL || __collector_mpi_stack_trace != NULL))
440 {
441 sz = OmpValTableSize * sizeof (*OmpCurCtxs);
442 OmpCurCtxs = (struct WalkContext *) __collector_allocCSize (__collector_heap, sz, 1);
443 sz = OmpValTableSize * sizeof (*OmpCtxs);
444 OmpCtxs = (struct WalkContext *) __collector_allocCSize (__collector_heap, sz, 1);
445 sz = OmpValTableSize * sizeof (*OmpVals);
446 OmpVals = (uint32_t*) __collector_allocCSize (__collector_heap, sz, 1);
447 sz = OmpValTableSize * sizeof (*OmpRAs);
448 OmpRAs = (unsigned long*) __collector_allocCSize (__collector_heap, sz, 1);
449 if (OmpCurCtxs == NULL || OmpCtxs == NULL || OmpVals == NULL || OmpRAs == NULL)
450 {
451 TprintfT (0, "unwind_init() ERROR: failed; terminating experiment\n");
452 __collector_terminate_expt ();
453 return;
454 }
455 }
456 #endif /* ARCH() */
457
458 if (record)
459 {
460 dhndl = __collector_create_handle (SP_FRINFO_FILE);
461 __collector_log_write ("<%s name=\"%s\" format=\"binary\"/>\n", SP_TAG_DATAPTR, SP_FRINFO_FILE);
462 }
463
464 unwind_key = __collector_tsd_create_key (sizeof (void*), NULL, NULL);
465 if (unwind_key == COLLECTOR_TSD_INVALID_KEY)
466 {
467 TprintfT (0, "unwind_init: ERROR: TSD key create failed.\n");
468 __collector_log_write ("<%s kind=\"%s\" id=\"%d\">TSD key not created</%s>\n",
469 SP_TAG_EVENT, SP_JCMD_CERROR, COL_ERROR_GENERAL, SP_TAG_EVENT);
470 return;
471 }
472 TprintfT (0, "unwind_init() completed normally\n");
473 return;
474 }
475
476 void
477 __collector_ext_unwind_close ()
478 {
479 __collector_delete_handle (dhndl);
480 dhndl = NULL;
481 }
482
483 void*
484 __collector_ext_return_address (unsigned level)
485 {
486 if (NULL == UIDTable) //unwind not initialized yet
487 return NULL;
488 unsigned size = (level + 4) * sizeof (long); // need to strip __collector_get_return_address and its caller
489 ucontext_t context;
490 FILL_CONTEXT ((&context));
491 char* buf = (char*) alloca (size);
492 if (buf == NULL)
493 {
494 TprintfT (DBG_LT0, "__collector_get_return_address: ERROR: alloca(%d) fails\n", size);
495 return NULL;
496 }
497 int sz = stack_unwind (buf, size, NULL, NULL, &context, 0);
498 if (sz < (level + 3) * sizeof (long))
499 {
500 TprintfT (DBG_LT0, "__collector_get_return_address: size=%d, but stack_unwind returns %d\n", size, sz);
501 return NULL;
502 }
503 long *lbuf = (long*) buf;
504 TprintfT (DBG_LT2, "__collector_get_return_address: return %lx\n", lbuf[level + 2]);
505 return (void *) (lbuf[level + 2]);
506 }
507 /*
508 * Collector interface method getFrameInfo
509 */
510 FrameInfo
511 __collector_get_frame_info (hrtime_t ts, int mode, void *arg)
512 {
513 ucontext_t *context = NULL;
514 void *bptr = NULL;
515 CM_Array *array = NULL;
516
517 int unwind_mode = 0;
518 int do_walk = 1;
519
520 if (mode & FRINFO_NO_WALK)
521 do_walk = 0;
522 int bmode = mode & 0xffff;
523 int pseudo_context = 0;
524 if (bmode == FRINFO_FROM_STACK_ARG || bmode == FRINFO_FROM_STACK)
525 {
526 bptr = arg;
527 context = (ucontext_t*) alloca (sizeof (ucontext_t));
528 FILL_CONTEXT (context);
529 unwind_mode |= bmode;
530 }
531 else if (bmode == FRINFO_FROM_UC)
532 {
533 context = (ucontext_t*) arg;
534 if (context == NULL)
535 return (FrameInfo) 0;
536 if (GET_SP (context) == 0)
537 pseudo_context = 1;
538 }
539 else if (bmode == FRINFO_FROM_ARRAY)
540 {
541 array = (CM_Array*) arg;
542 if (array == NULL || array->length <= 0)
543 return (FrameInfo) 0;
544 }
545 else
546 return (FrameInfo) 0;
547
548 int max_frame_size = OVERHEAD_BYTES + NATIVE_FRAME_BYTES (max_native_nframes);
549 if (__collector_java_mode && __collector_java_asyncgetcalltrace_loaded && context && !pseudo_context)
550 max_frame_size += JAVA_FRAME_BYTES (max_java_nframes);
551
552 Frame_packet *frpckt = alloca (sizeof (Frame_packet) + max_frame_size);
553 frpckt->type = FRAME_PCKT;
554 frpckt->hsize = sizeof (Frame_packet);
555
556 char *d = (char*) (frpckt + 1);
557 int size = max_frame_size;
558
559 #define MIN(a,b) ((a)<(b)?(a):(b))
560 #if defined(GPROFNG_JAVA_PROFILING)
561 /* get Java info */
562 if (__collector_java_mode && __collector_java_asyncgetcalltrace_loaded && context && !pseudo_context)
563 {
564 /* use only 2/3 of the buffer and leave the rest for the native stack */
565 int tmpsz = MIN (size, JAVA_FRAME_BYTES (max_java_nframes));
566 if (tmpsz > 0)
567 {
568 int sz = __collector_ext_jstack_unwind (d, tmpsz, context);
569 d += sz;
570 size -= sz;
571 }
572 }
573 #endif
574
575 /* get native stack */
576 if (context)
577 {
578 Stack_info *sinfo = (Stack_info*) d;
579 int sz = sizeof (Stack_info);
580 d += sz;
581 size -= sz;
582 #if ARCH(Intel)
583 if (omp_no_walk == 0)
584 do_walk = 1;
585 #endif
586 if (do_walk == 0)
587 unwind_mode |= FRINFO_NO_WALK;
588
589 int tmpsz = MIN (size, NATIVE_FRAME_BYTES (max_native_nframes));
590 if (tmpsz > 0)
591 {
592 sz = stack_unwind (d, tmpsz, bptr, NULL, context, unwind_mode);
593 d += sz;
594 size -= sz;
595 }
596 sinfo->kind = STACK_INFO;
597 sinfo->hsize = (d - (char*) sinfo);
598 }
599
600 /* create a stack image from user data */
601 if (array && array->length > 0)
602 {
603 Stack_info *sinfo = (Stack_info*) d;
604 int sz = sizeof (Stack_info);
605 d += sz;
606 size -= sz;
607 sz = array->length;
608 if (sz > size)
609 sz = size; // YXXX should we mark this with truncation frame?
610 __collector_memcpy (d, array->bytes, sz);
611 d += sz;
612 size -= sz;
613 sinfo->kind = STACK_INFO;
614 sinfo->hsize = (d - (char*) sinfo);
615 }
616
617 /* Compute the total size */
618 frpckt->tsize = d - (char*) frpckt;
619 FrameInfo uid = compute_uid (frpckt);
620 return uid;
621 }
622
623 FrameInfo
624 compute_uid (Frame_packet *frp)
625 {
626 uint64_t idxs[LAST_INFO];
627 uint64_t uid = ROOT_UID;
628 uint64_t idx = ROOT_IDX;
629
630 Common_info *cinfo = (Common_info*) ((char*) frp + frp->hsize);
631 char *end = (char*) frp + frp->tsize;
632 for (;;)
633 {
634 if ((char*) cinfo >= end || cinfo->hsize == 0 ||
635 (char*) cinfo + cinfo->hsize > end)
636 break;
637
638 /* Start with a different value to avoid matching with uid */
639 uint64_t uidt = 1;
640 uint64_t idxt = 1;
641 long *ptr = (long*) ((char*) cinfo + cinfo->hsize);
642 long *bnd = (long*) ((char*) cinfo + sizeof (Common_info));
643 TprintfT (DBG_LT2, "compute_uid: Cnt=%ld: ", (long) cinfo->hsize);
644 while (ptr > bnd)
645 {
646 long val = *(--ptr);
647 tprintf (DBG_LT2, "0x%8.8llx ", (unsigned long long) val);
648 uidt = (uidt + val) * ROOT_UID;
649 idxt = (idxt + val) * ROOT_IDX;
650 uid = (uid + val) * ROOT_UID;
651 idx = (idx + val) * ROOT_IDX;
652 }
653 if (cinfo->kind == STACK_INFO || cinfo->kind == JAVA_INFO)
654 {
655 cinfo->uid = uidt;
656 idxs[cinfo->kind] = idxt;
657 }
658 cinfo = (Common_info*) ((char*) cinfo + cinfo->hsize);
659 }
660 tprintf (DBG_LT2, "\n");
661
662 /* Check if we have already recorded that uid.
663 * The following fragment contains benign data races.
664 * It's important, though, that all reads from UIDTable
665 * happen before writes.
666 */
667 int found1 = 0;
668 int idx1 = (int) ((idx >> 44) % UIDTableSize);
669 if (UIDTable[idx1] == uid)
670 found1 = 1;
671 int found2 = 0;
672 int idx2 = (int) ((idx >> 24) % UIDTableSize);
673 if (UIDTable[idx2] == uid)
674 found2 = 1;
675 int found3 = 0;
676 int idx3 = (int) ((idx >> 4) % UIDTableSize);
677 if (UIDTable[idx3] == uid)
678 found3 = 1;
679 if (!found1)
680 UIDTable[idx1] = uid;
681 if (!found2)
682 UIDTable[idx2] = uid;
683 if (!found3)
684 UIDTable[idx3] = uid;
685
686 if (found1 || found2 || found3)
687 return (FrameInfo) uid;
688 frp->uid = uid;
689
690 /* Compress info's */
691 cinfo = (Common_info*) ((char*) frp + frp->hsize);
692 for (;;)
693 {
694 if ((char*) cinfo >= end || cinfo->hsize == 0 ||
695 (char*) cinfo + cinfo->hsize > end)
696 break;
697 if (cinfo->kind == STACK_INFO || cinfo->kind == JAVA_INFO)
698 {
699 long *ptr = (long*) ((char*) cinfo + sizeof (Common_info));
700 long *bnd = (long*) ((char*) cinfo + cinfo->hsize);
701 uint64_t uidt = cinfo->uid;
702 uint64_t idxt = idxs[cinfo->kind];
703 int found = 0;
704 int first = 1;
705 while (ptr < bnd - 1)
706 {
707 int idx1 = (int) ((idxt >> 44) % UIDTableSize);
708 if (UIDTable[idx1] == uidt)
709 {
710 found = 1;
711 break;
712 }
713 else if (first)
714 {
715 first = 0;
716 UIDTable[idx1] = uidt;
717 }
718 long val = *ptr++;
719 uidt = uidt * ROOT_UID_INV - val;
720 idxt = idxt * ROOT_IDX_INV - val;
721 }
722 if (found)
723 {
724 char *d = (char*) ptr;
725 char *s = (char*) bnd;
726 if (!first)
727 {
728 int i;
729 for (i = 0; i<sizeof (uidt); i++)
730 {
731 *d++ = (char) uidt;
732 uidt = uidt >> 8;
733 }
734 }
735 int delta = s - d;
736 while (s < end)
737 *d++ = *s++;
738 cinfo->kind |= COMPRESSED_INFO;
739 cinfo->hsize -= delta;
740 frp->tsize -= delta;
741 end -= delta;
742 }
743 }
744 cinfo = (Common_info*) ((char*) cinfo + cinfo->hsize);
745 }
746 __collector_write_packet (dhndl, (CM_Packet*) frp);
747 return (FrameInfo) uid;
748 }
749
750 FrameInfo
751 __collector_getUID (CM_Array *arg, FrameInfo suid)
752 {
753 if (arg->length % sizeof (long) != 0 ||
754 (long) arg->bytes % sizeof (long) != 0)
755 return (FrameInfo) - 1;
756 if (arg->length == 0)
757 return suid;
758
759 uint64_t uid = suid ? suid : 1;
760 uint64_t idx = suid ? suid : 1;
761 long *ptr = (long*) ((char*) arg->bytes + arg->length);
762 long *bnd = (long*) (arg->bytes);
763 while (ptr > bnd)
764 {
765 long val = *(--ptr);
766 uid = (uid + val) * ROOT_UID;
767 idx = (idx + val) * ROOT_IDX;
768 }
769
770 /* Check if we have already recorded that uid.
771 * The following fragment contains benign data races.
772 * It's important, though, that all reads from UIDTable
773 * happen before writes.
774 */
775 int found1 = 0;
776 int idx1 = (int) ((idx >> 44) % UIDTableSize);
777 if (UIDTable[idx1] == uid)
778 found1 = 1;
779 int found2 = 0;
780 int idx2 = (int) ((idx >> 24) % UIDTableSize);
781 if (UIDTable[idx2] == uid)
782 found2 = 1;
783 int found3 = 0;
784 int idx3 = (int) ((idx >> 4) % UIDTableSize);
785 if (UIDTable[idx3] == uid)
786 found3 = 1;
787
788 if (!found1)
789 UIDTable[idx1] = uid;
790 if (!found2)
791 UIDTable[idx2] = uid;
792 if (!found3)
793 UIDTable[idx3] = uid;
794 if (found1 || found2 || found3)
795 return (FrameInfo) uid;
796
797 int sz = sizeof (Uid_packet) + arg->length;
798 if (suid)
799 sz += sizeof (suid);
800 Uid_packet *uidp = alloca (sz);
801 uidp->tsize = sz;
802 uidp->type = UID_PCKT;
803 uidp->flags = 0;
804 uidp->uid = uid;
805
806 /* Compress */
807 ptr = (long*) (arg->bytes);
808 bnd = (long*) ((char*) arg->bytes + arg->length);
809 long *dst = (long*) (uidp + 1);
810 uint64_t uidt = uid;
811 uint64_t idxt = idx;
812 uint64_t luid = suid; /* link uid */
813
814 while (ptr < bnd)
815 {
816
817 long val = *ptr++;
818 *dst++ = val;
819
820 if ((bnd - ptr) > sizeof (uidt))
821 {
822 uidt = uidt * ROOT_UID_INV - val;
823 idxt = idxt * ROOT_IDX_INV - val;
824 int idx1 = (int) ((idxt >> 44) % UIDTableSize);
825 if (UIDTable[idx1] == uidt)
826 {
827 luid = uidt;
828 break;
829 }
830 }
831 }
832 if (luid)
833 {
834 char *d = (char*) dst;
835 for (int i = 0; i<sizeof (luid); i++)
836 {
837 *d++ = (char) luid;
838 luid = luid >> 8;
839 }
840 uidp->flags |= COMPRESSED_INFO;
841 uidp->tsize = d - (char*) uidp;
842 }
843 __collector_write_packet (dhndl, (CM_Packet*) uidp);
844
845 return (FrameInfo) uid;
846 }
847
848 int
849 __collector_getStackTrace (void *buf, int size, void *bptr, void *eptr, void *arg)
850 {
851 if (arg == (void*) __collector_omp_stack_trace)
852 seen_omp = 1;
853 int do_walk = 1;
854 if (arg == NULL || arg == (void*) __collector_omp_stack_trace)
855 {
856 do_walk = (arg == (void*) __collector_omp_stack_trace && omp_no_walk) ? 0 : 1;
857 ucontext_t *context = (ucontext_t*) alloca (sizeof (ucontext_t));
858 FILL_CONTEXT (context);
859 arg = context;
860 }
861 int unwind_mode = 0;
862 if (do_walk == 0)
863 unwind_mode |= FRINFO_NO_WALK;
864 return stack_unwind (buf, size, bptr, eptr, arg, unwind_mode);
865 }
866
867 #if ARCH(SPARC)
868 /*
869 * These are important data structures taken from the header files reg.h and
870 * ucontext.h. They are used for the stack trace algorithm explained below.
871 *
872 * typedef struct ucontext {
873 * u_long uc_flags;
874 * struct ucontext *uc_link;
875 * usigset_t uc_sigmask;
876 * stack_t uc_stack;
877 * mcontext_t uc_mcontext;
878 * long uc_filler[23];
879 * } ucontext_t;
880 *
881 * #define SPARC_MAXREGWINDOW 31
882 *
883 * struct rwindow {
884 * greg_t rw_local[8];
885 * greg_t rw_in[8];
886 * };
887 *
888 * #define rw_fp rw_in[6]
889 * #define rw_rtn rw_in[7]
890 *
891 * struct gwindows {
892 * int wbcnt;
893 * int *spbuf[SPARC_MAXREGWINDOW];
894 * struct rwindow wbuf[SPARC_MAXREGWINDOW];
895 * };
896 *
897 * typedef struct gwindows gwindows_t;
898 *
899 * typedef struct {
900 * gregset_t gregs;
901 * gwindows_t *gwins;
902 * fpregset_t fpregs;
903 * long filler[21];
904 * } mcontext_t;
905 *
906 * The stack would look like this when SIGPROF occurrs.
907 *
908 * ------------------------- <- high memory
909 * | |
910 * | |
911 * -------------------------
912 * | |
913 * ------------------------- <- fp' <-|
914 * | | |
915 * : : |
916 * | | |
917 * ------------------------- |
918 * | fp |----------|
919 * | |
920 * ------------------------- <- sp'
921 * | | | |
922 * | gwins | <- saved stack pointers & | |
923 * | | register windows | |- mcontext
924 * ------------------------- | |
925 * | gregs | <- saved registers | |
926 * ------------------------- |
927 * | | |- ucontext
928 * ------------------------- <- ucp (ucontext pointer) |
929 * | | |
930 * | | |- siginfo
931 * ------------------------- <- sip (siginfo pointer) |
932 * | |
933 * ------------------------- <- sp
934 *
935 * Then the signal handler is called with:
936 * handler( signo, sip, uip );
937 * When gwins is null, all the stack frames are saved in the user stack.
938 * In that case we can find sp' from gregs and walk the stack for a backtrace.
939 * However, if gwins is not null we will have a more complicated case.
940 * Wbcnt(in gwins) tells you how many saved register windows are valid.
941 * This is important because the kernel does not allocate the entire array.
942 * And the top most frame is saved in the lowest index element. The next
943 * paragraph explains the possible causes.
944 *
945 * There are two routines in the kernel to flush out user register windows.
946 * flush_user_windows and flush_user_windows_to_stack
947 * The first routine will not cause a page fault. Therefore if the user
948 * stack is not in memory, the register windows will be saved to the pcb.
949 * This can happen when the kernel is trying to deliver a signal and
950 * the user stack got swap out. The kernel will then build a new context for
951 * the signal handler and the saved register windows will
952 * be copied to the ucontext as show above. On the other hand,
953 * flush_user_windows_to_stack can cause a page fault, and if it failed
954 * then there is something wrong (stack overflow, misalign).
955 * The first saved register window does not necessary correspond to the
956 * first stack frame. So the current stack pointer must be compare with
957 * the stack pointers in spbuf to find a match.
958 *
959 * We will also follow the uc_link field in ucontext to trace also nested
960 * signal stack frames.
961 *
962 */
963
964 /* Dealing with trap handlers.
965 * When a user defined trap handler is invoked the return address
966 * (or actually the address of an instruction that raised the trap)
967 * is passed to the trap handler in %l6, whereas saved %o7 contains
968 * garbage. First, we need to find out if a particular pc belongs
969 * to the trap handler, and if so, take the %l6 value from the stack rather
970 * than %o7 from either the stack or the register.
971 * There are three possible situations represented
972 * by the following stacks:
973 *
974 * MARKER MARKER MARKER
975 * trap handler pc __func pc before 'save' __func pc after 'save'
976 * %l6 %o7 from reg %o7 (garbage)
977 * ... %l6 trap handler pc
978 * ... %l6
979 * ...
980 * where __func is a function called from the trap handler.
981 *
982 * Currently this is implemented to only deal with __misalign_trap_handler
983 * set for v9 FORTRAN applications. Implementation of IN_TRAP_HANDLER
984 * macro shows it. A general solution is postponed.
985 */
986
987 /* Special handling of unwind through the parallel loop barrier code:
988 *
989 * The library defines two symbols, __mt_EndOfTask_Barrier_ and
990 * __mt_EndOfTask_Barrier_Dummy_ representing the first word of
991 * the barrier sychronization code, and the first word following
992 * it. Whenever the leaf PC is between these two symbols,
993 * the unwind code is special-cased as follows:
994 * The __mt_EndOfTask_Barrier_ function is guaranteed to be a leaf
995 * function, so its return address is in a register, not saved on
996 * the stack.
997 *
998 * MARKER
999 * __mt_EndOfTask_Barrier_ PC -- the leaf PC
1000 * loop body function address for the task -- implied caller of __mt_EndOfTask_Barrier_
1001 * this address is taken from the %O0 register
1002 * {mt_master or mt_slave} -- real caller of __mt_EndOfTask_Barrier_
1003 * ...
1004 *
1005 * With this trick, the analyzer will show the time in the barrier
1006 * attributed to the loop at the end of which the barrier synchronization
1007 * is taking place. That loop body routine, will be shown as called
1008 * from the function from which it was extracted, which will be shown
1009 * as called from the real caller, either the slave or master library routine.
1010 */
1011
1012 /*
1013 * These no-fault-load (0x82) assembly functions are courtesy of Rob Gardner.
1014 *
1015 * Note that 0x82 is ASI_PNF. See
1016 * http://lxr.free-electrons.com/source/arch/sparc/include/uapi/asm/asi.h#L134
1017 * ASI address space identifier; PNF primary no fault
1018 */
1019
1020 /* load an int from an address */
1021
1022 /* if the address is illegal, return a 0 */
1023 static int
1024 SPARC_no_fault_load_int (void *addr)
1025 {
1026 int val;
1027 __asm__ __volatile__(
1028 "lda [%1] 0x82, %0\n\t"
1029 : "=r" (val)
1030 : "r" (addr)
1031 );
1032
1033 return val;
1034 }
1035
1036 /* check if an address is invalid
1037 *
1038 * A no-fault load of an illegal address still faults, but it does so silently to the calling process.
1039 * It returns a 0, but so could a load of a legal address.
1040 * So, we time the load. A "fast" load must be a successful load.
1041 * A "slow" load is probably a fault.
1042 * Since it could also be a cache/TLB miss or other abnormality,
1043 * it's safest to retry a slow load.
1044 * The cost of trying a valid address should be some nanosecs.
1045 * The cost of trying an invalid address up to 10 times could be some microsecs.
1046 */
1047 #if 0
1048 static
1049 int invalid_SPARC_addr(void *addr)
1050 {
1051 long t1, t2;
1052 int i;
1053
1054 for (i=0; i<10; i++) {
1055 __asm__ __volatile__(
1056 "rd %%tick, %0\n\t"
1057 "lduba [%2] 0x82, %%g0\n\t"
1058 "rd %%tick, %1\n\t"
1059 : "=r" (t1), "=r" (t2)
1060 : "r" (addr) );
1061 if ( (t2 - t1) < 100 )
1062 return 0;
1063 }
1064 return 1;
1065 }
1066 #endif
1067
1068 /*
1069 * The standard SPARC procedure-calling convention is that the
1070 * calling PC (for determining the return address when the procedure
1071 * is finished) is placed in register %o7. A called procedure
1072 * typically executes a "save" instruction that shifts the register
1073 * window, and %o7 becomes %i7.
1074 *
1075 * Optimized leaf procedures do not shift the register window.
1076 * They assume the return address will remain %o7. So when
1077 * we process a leaf PC, we walk instructions to see if there
1078 * is a call, restore, or other instruction that would indicate
1079 * we can IGNORE %o7 because this is NOT a leaf procedure.
1080 *
1081 * If a limited instruction walk uncovers no such hint, we save
1082 * not only the PC but the %o7 value as well... just to be safe.
1083 * Later, in DBE post-processing of the call stacks, we decide
1084 * whether any recorded %o7 value should be used as a caller
1085 * frame or should be discarded.
1086 */
1087
1088 #define IS_ILLTRAP(x) (((x) & 0xc1c00000) == 0)
1089 #define IS_SAVE(x) (((x) & 0xc1f80000) == 0x81e00000)
1090 #define IS_MOVO7R(x) (((x) & 0xc1f8201f) == 0x8160000f)
1091 #define IS_MOVRO7(x) (((x) & 0xfff82000) == 0x9f600000)
1092 #define IS_ORRG0O7(x) (((x) & 0xff78201f) == 0x9e100000)
1093 #define IS_ORG0RO7(x) (((x) & 0xff7fe000) == 0x9e100000)
1094 #define IS_ORG0O7R(x) (((x) & 0xc17fe01f) == 0x8010000f)
1095 #define IS_ORO7G0R(x) (((x) & 0xc17fe01f) == 0x8013c000)
1096 #define IS_RESTORE(x) (((x) & 0xc1f80000) == 0x81e80000)
1097 #define IS_RET(x) ((x) == 0x81c7e008)
1098 #define IS_RETL(x) ((x) == 0x81c3e008)
1099 #define IS_RETURN(x) (((x) & 0xc1f80000) == 0x81c80000)
1100 #define IS_BRANCH(x) ((((x) & 0xc0000000) == 0) && (((x) & 0x01c00000) != 0x01000000))
1101 #define IS_CALL(x) (((x) & 0xc0000000) == 0x40000000)
1102 #define IS_LDO7(x) (((x) & 0xfff80000) == 0xde000000)
1103
1104 static long pagesize = 0;
1105
1106 static int
1107 process_leaf (long *lbuf, int ind, int lsize, void *context)
1108 {
1109 greg_t pc = GET_PC (context);
1110 greg_t o7 = GET_GREG (context, REG_O7);
1111
1112 /* omazur: TBR START -- not used */
1113 if (IN_BARRIER (pc))
1114 {
1115 if (ind < lsize)
1116 lbuf[ind++] = pc;
1117 if (ind < lsize)
1118 lbuf[ind++] = GET_GREG (context, REG_O0);
1119 return ind;
1120 }
1121 /* omazur: TBR END */
1122 #if WSIZE(64)
1123 if (IN_TRAP_HANDLER (pc))
1124 {
1125 if (ind < lsize)
1126 lbuf[ind++] = pc;
1127 return ind;
1128 }
1129 #endif
1130 unsigned *instrp = (unsigned *) pc;
1131 unsigned *end_addr = instrp + 20;
1132 while (instrp < end_addr)
1133 {
1134 unsigned instr = *instrp++;
1135 if (IS_ILLTRAP (instr))
1136 break;
1137 else if (IS_SAVE (instr))
1138 {
1139 if (ind < lsize)
1140 lbuf[ind++] = pc;
1141 if (o7 && ind < lsize)
1142 lbuf[ind++] = o7;
1143 return ind;
1144 }
1145 else if (IS_MOVO7R (instr) || IS_ORG0O7R (instr) || IS_ORO7G0R (instr))
1146 break;
1147 else if (IS_MOVRO7 (instr) || IS_ORG0RO7 (instr))
1148 {
1149 int rs2 = (instr & 0x1f) + REG_G1 - 1;
1150 o7 = (rs2 <= REG_O7) ? GET_GREG (context, rs2) : 0;
1151 break;
1152 }
1153 else if (IS_ORRG0O7 (instr))
1154 {
1155 int rs2 = ((instr & 0x7c000) >> 14) + REG_G1 - 1;
1156 o7 = (rs2 <= REG_O7) ? GET_GREG (context, rs2) : 0;
1157 break;
1158 }
1159 else if (IS_RESTORE (instr))
1160 {
1161 o7 = 0;
1162 break;
1163 }
1164 else if (IS_RETURN (instr))
1165 {
1166 o7 = 0;
1167 break;
1168 }
1169 else if (IS_RET (instr))
1170 {
1171 o7 = 0;
1172 break;
1173 }
1174 else if (IS_RETL (instr))
1175 {
1176 /* process delay slot */
1177 instr = *instrp++;
1178 if (IS_RESTORE (instr))
1179 o7 = 0;
1180 break;
1181 }
1182 else if (IS_BRANCH (instr))
1183 {
1184 unsigned *backbegin = ((unsigned *) pc - 1);
1185 unsigned *backend = backbegin - 12 + (instrp - (unsigned *) pc);
1186 while (backbegin > backend)
1187 {
1188 // 21920143 stack unwind: SPARC process_leaf backtracks too far
1189 /*
1190 * We've already dereferenced backbegin+1.
1191 * So if backbegin is on the same page, we're fine.
1192 * If we've gone to a different page, possibly things are not fine.
1193 * We don't really know how to test that.
1194 * Let's just assume the worst: that dereferencing backbegin would segv.
1195 * We won't know if we're in a leaf function or not.
1196 */
1197 if (pagesize == 0)
1198 pagesize = CALL_UTIL (sysconf)(_SC_PAGESIZE);
1199 if ((((long) (backbegin + 1)) & (pagesize - 1)) < sizeof (unsigned*))
1200 break;
1201 unsigned backinstr = *backbegin--;
1202 if (IS_LDO7 (backinstr))
1203 {
1204 o7 = 0;
1205 break;
1206 }
1207 else if (IS_ILLTRAP (backinstr))
1208 break;
1209 else if (IS_RETURN (backinstr))
1210 break;
1211 else if (IS_RET (backinstr))
1212 break;
1213 else if (IS_RETL (backinstr))
1214 break;
1215 else if (IS_CALL (backinstr))
1216 break;
1217 else if (IS_SAVE (backinstr))
1218 {
1219 o7 = 0;
1220 break;
1221 }
1222 }
1223 break;
1224 }
1225 else if (IS_CALL (instr))
1226 o7 = 0;
1227 }
1228
1229 #if WSIZE(64)
1230 if (o7 != 0 && ((long) o7) < 32 && ((long) o7) > -32)
1231 {
1232 /* 20924821 SEGV in unwind code on SPARC/Linux
1233 * We've seen this condition in some SPARC-Linux runs.
1234 * o7 is non-zero but not a valid address.
1235 * Values like 4 or -7 have been seen.
1236 * Let's check if o7 is unreasonably small.
1237 * If so, set to 0 so that it won't be recorded.
1238 * Otherwise, there is risk of it being dereferenced in process_sigreturn().
1239 */
1240 // __collector_log_write("<event kind=\"%s\" id=\"%d\">time %lld, internal debug unwind at leaf; o7 = %ld, pc = %x</event>\n",
1241 // SP_JCMD_COMMENT, COL_COMMENT_NONE, __collector_gethrtime() - __collector_start_time, (long) o7, pc );
1242 o7 = 0;
1243 }
1244 #endif
1245
1246 if (o7)
1247 {
1248 if (ind < lsize)
1249 lbuf[ind++] = SP_LEAF_CHECK_MARKER;
1250 if (ind < lsize)
1251 lbuf[ind++] = pc;
1252 if (ind < lsize)
1253 lbuf[ind++] = o7;
1254 }
1255 else if (ind < lsize)
1256 lbuf[ind++] = pc;
1257 return ind;
1258 }
1259
1260 #if WSIZE(64)
1261 // detect signal handler
1262 static int
1263 process_sigreturn (long *lbuf, int ind, int lsize, unsigned char * tpc,
1264 struct frame **pfp, void * bptr, int extra_frame)
1265 {
1266 // cheap checks whether tpc is obviously not an instruction address
1267 if ((4096 > (unsigned long) tpc) // the first page is off limits
1268 || (3 & (unsigned long) tpc))
1269 return ind; // the address is not aligned
1270
1271 // get the instruction at tpc, skipping over as many as 7 nop's (0x01000000)
1272 int insn, i;
1273 for (i = 0; i < 7; i++)
1274 {
1275 insn = SPARC_no_fault_load_int ((void *) tpc);
1276 if (insn != 0x01000000)
1277 break;
1278 tpc += 4;
1279 }
1280
1281 // we're not expecting 0 (and it could mean an illegal address)
1282 if (insn == 0)
1283 return ind;
1284
1285 // We are looking for __rt_sigreturn_stub with the instruction
1286 // 0x82102065 : mov 0x65 /* __NR_rt_sigreturn */, %g1
1287 if (insn == 0x82102065)
1288 {
1289 /*
1290 * according to linux kernel source code,
1291 * syscall(_NR_rt_sigreturn) uses the following data in stack:
1292 * struct rt_signal_frame {
1293 * struct sparc_stackf ss;
1294 * siginfo_t info;
1295 * struct pt_regs regs;
1296 * ....};
1297 * sizeof(struct sparc_stackf) is 192;
1298 * sizeof(siginfo_t) is 128;
1299 * we need to get the register values from regs, which is defined as:
1300 * struct pt_regs {
1301 * unsigned long u_regs[16];
1302 * unsigned long tstate;
1303 * unsigned long tpc;
1304 * unsigned long tnpc;
1305 * ....};
1306 * pc and fp register has offset of 120 and 112;
1307 * the pc of kill() is stored in tnpc, whose offest is 136.
1308 */
1309 greg_t pc = *((unsigned long*) ((char*) ((*pfp)) + 192 + 128 + 136));
1310 greg_t pc1 = *((unsigned long*) ((char*) ((*pfp)) + 192 + 128 + 120));
1311 (*pfp) = *((struct frame**) ((char*) ((*pfp)) + 192 + 128 + 112));
1312 if (pc && pc1)
1313 {
1314 if (bptr != NULL && extra_frame && ((char*) (*pfp) + STACK_BIAS) < (char*) bptr && ind < 2)
1315 {
1316 lbuf[0] = pc1;
1317 if (ind == 0)
1318 ind++;
1319 }
1320 if (bptr == NULL || ((char*) (*pfp) + STACK_BIAS) >= (char*) bptr)
1321 {
1322 if (ind < lsize)
1323 lbuf[ind++] = (unsigned long) tpc;
1324 if (ind < lsize)
1325 lbuf[ind++] = pc;
1326 if (ind < lsize)
1327 lbuf[ind++] = pc1;
1328 }
1329 }
1330 DprintfT (SP_DUMP_UNWIND, "unwind.c: resolved sigreturn pc=0x%lx, pc1=0x%lx, fp=0x%lx\n", pc, pc1, *(pfp));
1331 }
1332 return ind;
1333 }
1334 #endif
1335
1336 /*
1337 * int stack_unwind( char *buf, int size, ucontext_t *context )
1338 * This routine looks into the mcontext and
1339 * trace stack frames to record return addresses.
1340 */
1341 int
1342 stack_unwind (char *buf, int size, void *bptr, void *eptr, ucontext_t *context, int mode)
1343 {
1344 /*
1345 * trace the stack frames from user stack.
1346 * We are assuming that the frame pointer and return address
1347 * are null when we are at the top level.
1348 */
1349 long *lbuf = (long*) buf;
1350 int lsize = size / sizeof (long);
1351 struct frame *fp = (struct frame *) GET_SP (context); /* frame pointer */
1352 greg_t pc; /* program counter */
1353 int extra_frame = 0;
1354 if ((mode & 0xffff) == FRINFO_FROM_STACK)
1355 extra_frame = 1;
1356
1357 int ind = 0;
1358 if (bptr == NULL)
1359 ind = process_leaf (lbuf, ind, lsize, context);
1360
1361 int extra_frame = 0;
1362 if ((mode & 0xffff) == FRINFO_FROM_STACK)
1363 extra_frame = 1;
1364 int ind = 0;
1365 if (bptr == NULL)
1366 ind = process_leaf (lbuf, ind, lsize, context);
1367
1368 while (fp)
1369 {
1370 if (ind >= lsize)
1371 break;
1372 fp = (struct frame *) ((char *) fp + STACK_BIAS);
1373 if (eptr && fp >= (struct frame *) eptr)
1374 {
1375 ind = ind >= 2 ? ind - 2 : 0;
1376 break;
1377 }
1378 #if WSIZE(64) // detect signal handler
1379 unsigned char * tpc = ((unsigned char*) (fp->fr_savpc));
1380 struct frame * tfp = (struct frame*) ((char*) (fp->fr_savfp) + STACK_BIAS);
1381 int old_ind = ind;
1382 ind = process_sigreturn (lbuf, old_ind, lsize, tpc, &tfp, bptr, extra_frame);
1383 if (ind != old_ind)
1384 {
1385 pc = (greg_t) tpc;
1386 fp = tfp;
1387 }
1388 else
1389 #endif
1390 {
1391 #if WSIZE(64)
1392 if (IN_TRAP_HANDLER (lbuf[ind - 1]))
1393 pc = fp->fr_local[6];
1394 else
1395 pc = fp->fr_savpc;
1396 #else
1397 pc = fp->fr_savpc;
1398 #endif
1399 fp = fp->fr_savfp;
1400 if (pc)
1401 {
1402 if (bptr != NULL && extra_frame && ((char*) fp + STACK_BIAS) < (char*) bptr && ind < 2)
1403 {
1404 lbuf[0] = pc;
1405 if (ind == 0)
1406 ind++;
1407 }
1408 if (bptr == NULL || ((char*) fp + STACK_BIAS) >= (char*) bptr)
1409 lbuf[ind++] = pc;
1410 }
1411 }
1412
1413 /* 4616238: _door_return may have a frame that has non-zero
1414 * saved stack pointer and zero pc
1415 */
1416 if (pc == (greg_t) NULL)
1417 break;
1418 }
1419
1420 if (ind >= lsize)
1421 { /* truncated stack handling */
1422 ind = lsize - 1;
1423 lbuf[ind++] = SP_TRUNC_STACK_MARKER;
1424 }
1425 return ind * sizeof (long);
1426 }
1427
1428 #elif ARCH(Intel)
1429
1430 /* get __NR_<syscall_name> constants */
1431 #include <syscall.h>
1432
1433 /*
1434 * From uts/intel/ia32/os/sendsig.c:
1435 *
1436 * An amd64 signal frame looks like this on the stack:
1437 *
1438 * old %rsp:
1439 * <128 bytes of untouched stack space>
1440 * <a siginfo_t [optional]>
1441 * <a ucontext_t>
1442 * <siginfo_t *>
1443 * <signal number>
1444 * new %rsp: <return address (deliberately invalid)>
1445 *
1446 * The signal number and siginfo_t pointer are only pushed onto the stack in
1447 * order to allow stack backtraces. The actual signal handling code expects the
1448 * arguments in registers.
1449 *
1450 * An i386 SVR4/ABI signal frame looks like this on the stack:
1451 *
1452 * old %esp:
1453 * <a siginfo32_t [optional]>
1454 * <a ucontext32_t>
1455 * <pointer to that ucontext32_t>
1456 * <pointer to that siginfo32_t>
1457 * <signo>
1458 * new %esp: <return address (deliberately invalid)>
1459 */
1460
1461 #if WSIZE(32)
1462 #define OPC_REG(x) ((x)&0x7)
1463 #define MRM_REGD(x) (((x)>>3)&0x7)
1464 #define MRM_REGS(x) ((x)&0x7)
1465 #define RED_ZONE 0
1466 #elif WSIZE(64)
1467 #define OPC_REG(x) (B|((x)&0x7))
1468 #define MRM_REGD(x) (R|(((x)>>3)&0x7))
1469 #define MRM_REGS(x) (B|((x)&0x7))
1470 #define RED_ZONE 16
1471 #endif
1472 #define MRM_EXT(x) (((x)>>3)&0x7)
1473 #define MRM_MOD(x) ((x)&0xc0)
1474
1475 #define RAX 0
1476 #define RDX 2
1477 #define RSP 4
1478 #define RBP 5
1479
1480 struct AdvWalkContext
1481 {
1482 unsigned char *pc;
1483 unsigned long *sp;
1484 unsigned long *sp_safe;
1485 unsigned long *fp;
1486 unsigned long *fp_sav;
1487 unsigned long *fp_loc;
1488 unsigned long rax;
1489 unsigned long rdx;
1490 unsigned long ra_sav;
1491 unsigned long *ra_loc;
1492 unsigned long regs[16];
1493 int tidx; /* targets table index */
1494 uint32_t cval; /* cache value */
1495 };
1496
1497 static unsigned long
1498 getRegVal (struct AdvWalkContext *cur, int r, int *undefRez)
1499 {
1500 if (cur->regs[r] == 0)
1501 {
1502 if (r == RBP)
1503 {
1504 tprintf (DBG_LT3, "getRegVal: returns cur->regs[RBP]=0x%lx cur->pc=0x%lx\n",
1505 (unsigned long) cur->fp, (unsigned long) cur->pc);
1506 return (unsigned long) cur->fp;
1507 }
1508 *undefRez = 1;
1509 }
1510 tprintf (DBG_LT3, "getRegVal: cur->regs[%d]=0x%lx cur->pc=0x%lx\n",
1511 r, (unsigned long) cur->regs[r], (unsigned long) cur->pc);
1512 return cur->regs[r];
1513 }
1514
1515 static unsigned char *
1516 check_modrm (unsigned char *pc)
1517 {
1518 unsigned char modrm = *pc++;
1519 unsigned char mod = MRM_MOD (modrm);
1520 if (mod == 0xc0)
1521 return pc;
1522 unsigned char regs = modrm & 0x07;
1523 if (regs == RSP)
1524 {
1525 if (mod == 0x40)
1526 return pc + 2; // SIB + disp8
1527 if (mod == 0x80)
1528 return pc + 5; // SIB + disp32
1529 return pc + 1; // SIB
1530 }
1531 if (mod == 0x0)
1532 {
1533 if (regs == RBP)
1534 pc += 4; // disp32
1535 }
1536 else if (mod == 0x40)
1537 pc += 1; /* byte */
1538 else if (mod == 0x80)
1539 pc += 4; /* word */
1540 return pc;
1541 }
1542
1543 static int
1544 read_int (unsigned char *pc, int w)
1545 {
1546 if (w == 1)
1547 return *((char *) pc);
1548 if (w == 2)
1549 return *(short*) pc;
1550 return *(int*) pc;
1551 }
1552
1553 /* Return codes */
1554 enum
1555 {
1556 RA_FAILURE = 0,
1557 RA_SUCCESS,
1558 RA_END_OF_STACK,
1559 RA_SIGRETURN,
1560 RA_RT_SIGRETURN
1561 };
1562
1563 /* Cache value encodings */
1564 static const uint32_t RA_FROMFP = (uint32_t) - 1; /* get the RA from the frame pointer */
1565 static const uint32_t RA_EOSTCK = (uint32_t) - 2; /* end-of-stack */
1566
1567
1568 #define MAXCTX 16
1569 #define MAXTRGTS 64
1570 #define MAXJMPREG 2
1571 #define MAXJMPREGCTX 3
1572
1573 #define DELETE_CURCTX() __collector_memcpy (cur, buf + (--nctx), sizeof (*cur))
1574
1575 /**
1576 * Look for pc in AddrTable_RA_FROMFP and in AddrTable_RA_EOSTCK
1577 * @param wctx
1578 * @return
1579 */
1580 static int
1581 cache_get (struct WalkContext *wctx)
1582 {
1583 unsigned long addr;
1584 if (AddrTable_RA_FROMFP != NULL)
1585 {
1586 uint64_t idx = wctx->pc % ValTableSize;
1587 addr = AddrTable_RA_FROMFP[ idx ];
1588 if (addr == wctx->pc)
1589 { // Found in AddrTable_RA_FROMFP
1590 unsigned long *sp = NULL;
1591 unsigned long fp = wctx->fp;
1592 /* validate fp before use */
1593 if (fp < wctx->sp || fp >= wctx->sbase - sizeof (*sp))
1594 return RA_FAILURE;
1595 sp = (unsigned long *) fp;
1596 fp = *sp++;
1597 unsigned long ra = *sp++;
1598 unsigned long tbgn = wctx->tbgn;
1599 unsigned long tend = wctx->tend;
1600 if (ra < tbgn || ra >= tend)
1601 if (!__collector_check_segment (ra, &tbgn, &tend, 0))
1602 return RA_FAILURE;
1603 unsigned long npc = adjust_ret_addr (ra, ra - tbgn, tend);
1604 if (npc == 0)
1605 return RA_FAILURE;
1606 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d cached pc=0x%lX\n", __LINE__, npc);
1607 wctx->pc = npc;
1608 wctx->sp = (unsigned long) sp;
1609 wctx->fp = fp;
1610 wctx->tbgn = tbgn;
1611 wctx->tend = tend;
1612 return RA_SUCCESS;
1613 }
1614 }
1615 if (NULL == AddrTable_RA_EOSTCK)
1616 return RA_FAILURE;
1617 uint64_t idx = wctx->pc % ValTableSize;
1618 addr = AddrTable_RA_EOSTCK[ idx ];
1619 if (addr != wctx->pc)
1620 return RA_FAILURE;
1621 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d cached RA_END_OF_STACK\n", __LINE__);
1622 return RA_END_OF_STACK;
1623 }
1624 /**
1625 * Save pc in RA_FROMFP or RA_EOSTCK cache depending on val
1626 * @param wctx
1627 */
1628 static void
1629 cache_put (struct WalkContext *wctx, const uint32_t val)
1630 {
1631 if (RA_FROMFP == val)
1632 {
1633 // save pc in RA_FROMFP cache
1634 if (NULL != AddrTable_RA_FROMFP)
1635 {
1636 uint64_t idx = wctx->pc % ValTableSize;
1637 AddrTable_RA_FROMFP[ idx ] = wctx->pc;
1638 if (NULL != AddrTable_RA_EOSTCK)
1639 if (AddrTable_RA_EOSTCK[ idx ] == wctx->pc)
1640 // invalidate pc in RA_EOSTCK cache
1641 AddrTable_RA_EOSTCK[ idx ] = 0;
1642 }
1643 return;
1644 }
1645 if (RA_EOSTCK == val)
1646 {
1647 // save pc in RA_EOSTCK cache
1648 if (NULL != AddrTable_RA_EOSTCK)
1649 {
1650 uint64_t idx = wctx->pc % ValTableSize;
1651 AddrTable_RA_EOSTCK[ idx ] = wctx->pc;
1652 if (NULL != AddrTable_RA_FROMFP)
1653 {
1654 if (AddrTable_RA_FROMFP[ idx ] == wctx->pc)
1655 // invalidate pc in RA_FROMFP cache
1656 AddrTable_RA_FROMFP[ idx ] = 0;
1657 }
1658 }
1659 return;
1660 }
1661 }
1662
1663 static int
1664 process_return_real (struct WalkContext *wctx, struct AdvWalkContext *cur, int cache_on)
1665 {
1666 if ((unsigned long) cur->sp >= wctx->sbase ||
1667 (unsigned long) cur->sp < wctx->sp)
1668 {
1669 DprintfT (SP_DUMP_UNWIND, "unwind.c: not in stack: %p [0x%lX-0x%lX]\n",
1670 cur->sp, wctx->sp, wctx->sbase);
1671 return RA_FAILURE;
1672 }
1673
1674 unsigned long ra;
1675 if (cur->sp == cur->ra_loc)
1676 {
1677 ra = cur->ra_sav;
1678 cur->sp++;
1679 }
1680 else if (cur->sp >= cur->sp_safe && (unsigned long) cur->sp < wctx->sbase)
1681 ra = *cur->sp++;
1682 else
1683 {
1684 DprintfT (SP_DUMP_UNWIND, "unwind.c: not safe: %p >= %p\n", cur->sp, cur->sp_safe);
1685 return RA_FAILURE;
1686 }
1687 if (ra == 0)
1688 {
1689 if (cache_on)
1690 cache_put (wctx, RA_EOSTCK);
1691 wctx->pc = ra;
1692 wctx->sp = (unsigned long) cur->sp;
1693 wctx->fp = (unsigned long) cur->fp;
1694 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d RA_END_OF_STACK\n", __LINE__);
1695 return RA_END_OF_STACK;
1696 }
1697
1698 unsigned long tbgn = wctx->tbgn;
1699 unsigned long tend = wctx->tend;
1700 if (ra < tbgn || ra >= tend)
1701 {
1702 if (!__collector_check_segment (ra, &tbgn, &tend, 0))
1703 {
1704 DprintfT (SP_DUMP_UNWIND, "unwind.c: not in segment: 0x%lX [0x%lX-0x%lX]\n",
1705 ra, wctx->tbgn, wctx->tend);
1706 return RA_FAILURE;
1707 }
1708 }
1709
1710 if (cur->cval == RA_FROMFP)
1711 {
1712 if (wctx->fp == (unsigned long) (cur->sp - 2))
1713 {
1714 if (cache_on)
1715 cache_put (wctx, RA_FROMFP);
1716 }
1717 else
1718 cur->cval = 0;
1719 }
1720
1721 unsigned long npc = adjust_ret_addr (ra, ra - tbgn, tend);
1722 if (npc == 0)
1723 {
1724 if (cur->cval == RA_FROMFP)
1725 {
1726 /* We have another evidence that we can trust this RA */
1727 DprintfT (SP_DUMP_UNWIND, "unwind.c: trusted fp, pc = 0x%lX\n", wctx->pc);
1728 wctx->pc = ra;
1729 }
1730 else
1731 {
1732 DprintfT (SP_DUMP_UNWIND, "unwind.c: 0 after adjustment\n");
1733 return RA_FAILURE;
1734 }
1735 }
1736 else
1737 wctx->pc = npc;
1738 wctx->sp = (unsigned long) cur->sp;
1739 wctx->fp = (unsigned long) cur->fp;
1740 wctx->tbgn = tbgn;
1741 wctx->tend = tend;
1742 return RA_SUCCESS;
1743 }
1744
1745 static int
1746 process_return (struct WalkContext *wctx, struct AdvWalkContext *cur)
1747 {
1748 return process_return_real (wctx, cur, 1);
1749 }
1750
1751 static void
1752 omp_cache_put (unsigned long *cur_sp_safe, struct WalkContext * wctx_pc_save,
1753 struct WalkContext *wctx, uint32_t val)
1754 {
1755 if (omp_no_walk && (OmpCurCtxs == NULL || OmpCtxs == NULL || OmpVals == NULL || OmpRAs == NULL))
1756 {
1757 size_t sz = OmpValTableSize * sizeof (*OmpCurCtxs);
1758 OmpCurCtxs = (struct WalkContext *) __collector_allocCSize (__collector_heap, sz, 1);
1759 sz = OmpValTableSize * sizeof (*OmpCtxs);
1760 OmpCtxs = (struct WalkContext *) __collector_allocCSize (__collector_heap, sz, 1);
1761 sz = OmpValTableSize * sizeof (*OmpVals);
1762 OmpVals = (uint32_t*) __collector_allocCSize (__collector_heap, sz, 1);
1763 sz = OmpValTableSize * sizeof (*OmpRAs);
1764 OmpRAs = (unsigned long*) __collector_allocCSize (__collector_heap, sz, 1);
1765 }
1766 if (OmpCurCtxs == NULL || OmpCtxs == NULL || OmpVals == NULL || OmpRAs == NULL)
1767 return;
1768
1769 #define USE_18434988_OMP_CACHE_WORKAROUND
1770 #ifndef USE_18434988_OMP_CACHE_WORKAROUND
1771 uint64_t idx = wctx_pc_save->pc * ROOT_IDX;
1772 OmpVals[ idx % OmpValTableSize ] = val;
1773 idx = (idx + val) * ROOT_IDX;
1774 __collector_memcpy (&(OmpCurCtxs[ idx % OmpValTableSize ]), wctx_pc_save, sizeof (struct WalkContext));
1775 idx = (idx + val) * ROOT_IDX;
1776 __collector_memcpy (&(OmpCtxs[ idx % OmpValTableSize ]), wctx, sizeof (struct WalkContext));
1777 #endif
1778 unsigned long *sp = NULL;
1779 unsigned long fp = wctx_pc_save->fp;
1780 int from_fp = 0;
1781 if (val == RA_END_OF_STACK)
1782 {
1783 sp = (unsigned long *) (wctx->sp);
1784 sp--;
1785 TprintfT (DBG_LT1, "omp_cache_put: get sp from EOS, sp=%p\n", sp);
1786 }
1787 else
1788 {
1789 if (fp < wctx_pc_save->sp || fp >= wctx_pc_save->sbase - sizeof (*sp))
1790 {
1791 sp = (unsigned long *) (wctx->sp);
1792 sp--;
1793 TprintfT (DBG_LT1, "omp_cache_put: get sp from sp, sp=%p\n", sp);
1794 }
1795 else
1796 {
1797 TprintfT (DBG_LT1, "omp_cache_put: get sp from fp=0x%lx\n", fp);
1798 sp = (unsigned long *) fp;
1799 from_fp = 1;
1800 }
1801 }
1802
1803 if (sp < cur_sp_safe || ((unsigned long) sp >= wctx->sbase))
1804 return;
1805
1806 unsigned long ra = *sp++;
1807 if (from_fp)
1808 {
1809 unsigned long tbgn = wctx_pc_save->tbgn;
1810 unsigned long tend = wctx_pc_save->tend;
1811 if (ra < tbgn || ra >= tend)
1812 {
1813 sp = (unsigned long *) (wctx->sp);
1814 sp--;
1815 ra = *sp++;
1816 }
1817 }
1818 #ifdef USE_18434988_OMP_CACHE_WORKAROUND
1819 uint64_t idx1 = wctx_pc_save->pc * ROOT_IDX;
1820 uint64_t idx2 = (idx1 + val) * ROOT_IDX;
1821 uint64_t idx3 = (idx2 + val) * ROOT_IDX;
1822 uint64_t idx4 = (idx3 + val) * ROOT_IDX;
1823 OmpRAs [ idx4 % OmpValTableSize ] = 0; // lock
1824 OmpVals[ idx1 % OmpValTableSize ] = val;
1825 __collector_memcpy (&(OmpCurCtxs[ idx2 % OmpValTableSize ]), wctx_pc_save, sizeof (struct WalkContext));
1826 __collector_memcpy (&(OmpCtxs [ idx3 % OmpValTableSize ]), wctx, sizeof (struct WalkContext));
1827 OmpRAs [ idx4 % OmpValTableSize ] = ra;
1828 #else
1829 idx = (idx + val) * ROOT_IDX;
1830 OmpRAs[ idx % OmpValTableSize ] = ra;
1831 #endif
1832 TprintfT (DBG_LT1, "omp_cache_put: pc=0x%lx\n", wctx_pc_save->pc);
1833 }
1834
1835 /*
1836 * See bug 17166877 - malloc_internal unwind failure.
1837 * Sometimes there are several calls right after ret, like:
1838 * leave
1839 * ret
1840 * call xxx
1841 * call xxxx
1842 * call xxxxx
1843 * If they are also jump targets, we should better not
1844 * create new jump context for those, since they may
1845 * end up into some other function.
1846 */
1847 static int
1848 is_after_ret (unsigned char * npc)
1849 {
1850 if (*npc != 0xe8)
1851 return 0;
1852 unsigned char * onpc = npc;
1853 int ncall = 1;
1854 int maxsteps = 10;
1855 int mincalls = 3;
1856 int steps = 0;
1857 while (*(npc - 5) == 0xe8 && steps < maxsteps)
1858 {
1859 npc -= 5;
1860 ncall++;
1861 steps++;
1862 }
1863 if (*(npc - 1) != 0xc3 || *(npc - 2) != 0xc9)
1864 return 0;
1865 steps = 0;
1866 while (*(onpc + 5) == 0xe8 && steps < maxsteps)
1867 {
1868 onpc += 5;
1869 ncall++;
1870 steps++;
1871 }
1872 if (ncall < mincalls)
1873 return 0;
1874 return 1;
1875 }
1876
1877 static int
1878 find_i386_ret_addr (struct WalkContext *wctx, int do_walk)
1879 {
1880 if (wctx->sp == 0)
1881 // Some artificial contexts may have %sp set to 0. See SETFUNCTIONCONTEXT()
1882 return RA_FAILURE;
1883
1884 /* Check cached values */
1885 int retc = cache_get (wctx);
1886 if (retc != RA_FAILURE)
1887 return retc;
1888
1889 /* An attempt to perform code analysis for call stack tracing */
1890 unsigned char opcode;
1891 unsigned char extop;
1892 unsigned char extop2;
1893 unsigned char modrm;
1894 int imm8; /* immediate operand, byte */
1895 int immv; /* immediate operand, word(2) or doubleword(4) */
1896 int reg; /* register code */
1897
1898 /* Buffer for branch targets (analysis stoppers) */
1899 unsigned char *targets[MAXTRGTS];
1900 int ntrg = 0; /* number of entries in the table */
1901 targets[ntrg++] = (unsigned char*) wctx->pc;
1902 targets[ntrg++] = (unsigned char*) - 1;
1903
1904 struct AdvWalkContext buf[MAXCTX];
1905 struct AdvWalkContext *cur = buf;
1906 CALL_UTIL (memset)((void*) cur, 0, sizeof (*cur));
1907
1908 cur->pc = (unsigned char*) wctx->pc;
1909 cur->sp = (unsigned long*) wctx->sp;
1910 cur->sp_safe = cur->sp - RED_ZONE; /* allow for the 128-byte red zone on amd64 */
1911 cur->fp = (unsigned long*) wctx->fp;
1912 cur->tidx = 1;
1913 DprintfT (SP_DUMP_UNWIND, "\nstack_unwind (x86 walk):%d %p start\n", __LINE__, cur->pc);
1914
1915 int nctx = 1; /* number of contexts being processed */
1916 int cnt = 8192; /* number of instructions to analyse */
1917
1918 /*
1919 * The basic idea of our x86 stack unwind is that we don't know
1920 * if we can trust the frame-pointer register. So we walk
1921 * instructions to find a return instruction, at which point
1922 * we know the return address is on the top of the stack, etc.
1923 *
1924 * A severe challenge to walking x86 instructions is when we
1925 * encounter "jmp *(reg)" instructions, where we are expected
1926 * to jump to the (unknown-to-us) contents of a register.
1927 *
1928 * The "jmp_reg" code here attempts to keep track of the
1929 * context for such a jump, deferring any handling of such
1930 * a difficult case. We continue with other contexts, hoping
1931 * that some other walk will take us to a return instruction.
1932 *
1933 * If no other walk helps, we return to "jmp_reg" contexts.
1934 * While we don't know the jump target, it is possible that the
1935 * bytes immediately following the jmp_reg instruction represent
1936 * one possible target, as might be the case when a "switch"
1937 * statement is compiled.
1938 *
1939 * Unfortunately, the bytes following a "jmp_reg" instruction might
1940 * instead be a jump target from somewhere else -- execution might
1941 * never "fall through" from the preceding "jmp_reg". Those bytes
1942 * might not even be instructions at all. There are many uses of
1943 * jmp_reg instructions beyond just compiling switch statements.
1944 *
1945 * So walking the bytes after a "jmp_reg" instruction can lead
1946 * to bugs and undefined behavior, including SEGV and core dump.
1947 *
1948 * We currently do not really understand the "jmp_reg" code below.
1949 */
1950 int jmp_reg_switch_mode = 0;
1951 int num_jmp_reg = 0; // number of jmp *reg met when switch mode is off or when in current switch case
1952 int total_num_jmp_reg = 0; // number of total jmp *reg met
1953 struct AdvWalkContext * jmp_reg_ctx[MAXJMPREG]; // context of jmp *reg met when switch mode is off or when in current switch case
1954 struct AdvWalkContext * jmp_reg_switch_ctx[MAXJMPREG]; // context of jmp *reg used in switch cases
1955 struct AdvWalkContext * jmp_reg_switch_backup_ctx = NULL; // context of the first jmp *reg used in switch cases
1956
1957 int cur_jmp_reg_switch = 0; // current switch table
1958 int num_jmp_reg_switch = 0; // number of switch table
1959 int jmp_reg_switch_case = 0; // case number in current switch table
1960 unsigned char * jmp_reg_switch_pc = NULL; // the start pc of current switch case
1961 unsigned char * jmp_reg_switch_pc_old = NULL; // backup for deleteing context of jump target
1962 unsigned char * jmp_reg_switch_base = NULL; // start pc for checking offsets
1963 int max_jmp_reg_switch_case = 2;
1964 #if WSIZE(32)
1965 int max_switch_pc_offset = 512;
1966 #else // WSIZE(64)
1967 int max_switch_pc_offset = 1024;
1968 #endif
1969 int expected_num_jmp_reg = 1; // should be smaller than MAXJMPREG
1970 int max_num_jmp_reg_seen = 4; // try to resolve return if there are so many such instructions
1971
1972
1973 int save_ctx = 0; // flag to save walk context in the cache to speed up unwind
1974 struct WalkContext wctx_pc_save;
1975 if (do_walk == 0)
1976 // do_walk is the flag indicating not walking through the instructions, resolving the RA from the stack fp first
1977 __collector_memcpy (&wctx_pc_save, wctx, sizeof (struct WalkContext));
1978
1979 startWalk:
1980 if (do_walk == 0)
1981 { // try to resolve RA from stack frame pointer
1982 if (OmpCurCtxs == NULL || OmpCtxs == NULL || OmpVals == NULL || OmpRAs == NULL)
1983 {
1984 do_walk = 1;
1985 goto startWalk;
1986 }
1987 // before goto checkFP, try the RA from cache (key: WalkContext -> value: caller's WalkContext))
1988 uint64_t idx = wctx->pc * ROOT_IDX;
1989 uint32_t val = OmpVals[idx % OmpValTableSize];
1990 idx = (idx + val) * ROOT_IDX;
1991 #ifdef USE_18434988_OMP_CACHE_WORKAROUND
1992 // Check ra: if it is 0 - then cache is invalid
1993 uint64_t idx4;
1994 idx4 = (idx + val) * ROOT_IDX;
1995 idx4 = (idx4 + val) * ROOT_IDX;
1996 if (0 == OmpRAs[ idx4 % OmpValTableSize ]) // Invalid cache
1997 goto checkFP;
1998 #endif
1999 struct WalkContext saved_ctx;
2000 __collector_memcpy (&saved_ctx, &OmpCurCtxs[ idx % OmpValTableSize ], sizeof (struct WalkContext));
2001 if (wctx->pc == saved_ctx.pc
2002 && wctx->sp == saved_ctx.sp
2003 && wctx->fp == saved_ctx.fp
2004 && wctx->tbgn == saved_ctx.tbgn
2005 && wctx->tend == saved_ctx.tend)
2006 { // key match, RA may be valid
2007 idx = (idx + val) * ROOT_IDX;
2008 unsigned long *sp = NULL;
2009 unsigned long fp = wctx->fp;
2010 int from_fp = 0;
2011 if (val == RA_END_OF_STACK)
2012 {
2013 DprintfT (SP_DUMP_UNWIND, "find_i386_ret_addr:%d -- RA_END_OF_STACK: pc=0x%lx\n", __LINE__, wctx->pc);
2014 __collector_memcpy (wctx, &OmpCtxs[ idx % OmpValTableSize ], sizeof (struct WalkContext));
2015 return val;
2016 }
2017 else
2018 {
2019 if (fp < wctx->sp || fp >= wctx->sbase - sizeof (*sp))
2020 {
2021 TprintfT (DBG_LT1, "omp_cache_get -- wrong fp: pc=0x%lx\n", wctx->pc);
2022 sp = (unsigned long *) (OmpCtxs[ idx % OmpValTableSize ].sp);
2023 sp--;
2024 if (sp < cur->sp_safe || (unsigned long) sp >= wctx->sbase)
2025 {
2026 goto checkFP;
2027 }
2028 unsigned long ra = *sp;
2029 uint64_t idx2 = (idx + val) * ROOT_IDX;
2030 if (OmpRAs[ idx2 % OmpValTableSize ] == ra)
2031 {
2032 __collector_memcpy (wctx, &OmpCtxs[ idx % OmpValTableSize ], sizeof (struct WalkContext));
2033 TprintfT (DBG_LT1, "omp_cache_get -- ra match with target sp: pc=0x%lx, ra=0x%lx, val=%d\n", wctx->pc, ra, val);
2034 return val;
2035 }
2036 TprintfT (DBG_LT1, "omp_cache_get -- ra mismatch: ra=0x%lx, expected ra=0x%lx, val=%d\n", ra, OmpRAs[ idx2 % OmpValTableSize ], val);
2037 goto checkFP;
2038 }
2039 sp = (unsigned long *) fp;
2040 from_fp = 1;
2041 }
2042
2043 uint64_t idx2 = (idx + val) * ROOT_IDX;
2044 unsigned long ra = *sp++;
2045 if (from_fp)
2046 {
2047 unsigned long tbgn = wctx->tbgn;
2048 unsigned long tend = wctx->tend;
2049 if (ra < tbgn || ra >= tend)
2050 {
2051 sp = (unsigned long *) (OmpCtxs[ idx % OmpValTableSize ].sp);
2052 sp--;
2053 //if (sp < cur->sp_safe - 16 || (unsigned long)sp >= wctx->sbase - sizeof(*sp)) {
2054 // The check above was replaced with the check below,
2055 // because we do not know why "- 16" and "- sizeof(*sp)" was used.
2056 if (sp < cur->sp_safe || (unsigned long) sp >= wctx->sbase)
2057 goto checkFP;
2058 else
2059 ra = *sp;
2060 }
2061 }
2062 if (OmpRAs[ idx2 % OmpValTableSize ] == ra)
2063 {
2064 TprintfT (DBG_LT1, "omp_cache_get -- ra match: pc=0x%lx\n", wctx->pc);
2065 __collector_memcpy (wctx, &OmpCtxs[ idx % OmpValTableSize ], sizeof (struct WalkContext));
2066 return val;
2067 }
2068 }
2069 goto checkFP;
2070 }
2071 else
2072 {
2073 CALL_UTIL (memset)(jmp_reg_ctx, 0, MAXJMPREG * sizeof (struct AdvWalkContext *));
2074 CALL_UTIL (memset)(jmp_reg_switch_ctx, 0, MAXJMPREG * sizeof (struct AdvWalkContext *));
2075 }
2076 while (cnt--)
2077 {
2078 if (nctx == 0 && (num_jmp_reg == expected_num_jmp_reg || jmp_reg_switch_mode == 1))
2079 { // no context available, try jmp switch mode
2080 int i = 0;
2081 if (num_jmp_reg == expected_num_jmp_reg)
2082 jmp_reg_switch_mode = 0; // first jmp reg expected, restart switch mode
2083 DprintfT (SP_DUMP_UNWIND, "unwind.c: begin switch mode, num_jmp_reg = %d, jmp_reg_switch_backup_ctx=%p, jmp_reg_switch_case=%d, jmp_reg_switch_mode=%d.\n",
2084 num_jmp_reg, jmp_reg_switch_backup_ctx, jmp_reg_switch_case, jmp_reg_switch_mode);
2085 // the ideal asm of switch is
2086 // jmp reg
2087 // ...//case 1
2088 // ret
2089 // ...//case 2
2090 // ret
2091 // ...//etc
2092 if (jmp_reg_switch_mode == 0)
2093 {
2094 num_jmp_reg_switch = num_jmp_reg; // backup num_jmp_reg
2095 jmp_reg_switch_mode = 1; // begin switch mode
2096 for (i = 0; i < num_jmp_reg_switch; i++)
2097 {
2098 if (jmp_reg_switch_ctx[i] == NULL)
2099 jmp_reg_switch_ctx[i] = (struct AdvWalkContext*) alloca (sizeof (*jmp_reg_switch_ctx[i]));
2100 if (jmp_reg_switch_ctx[i] != NULL)
2101 { // backup jmp_reg_ctx
2102 __collector_memcpy (jmp_reg_switch_ctx[i], jmp_reg_ctx[i], sizeof (*jmp_reg_switch_ctx[i]));
2103 cur_jmp_reg_switch = 0; // reset the current switch table
2104 jmp_reg_switch_case = 0; // reset the case number in current switch table
2105 }
2106 }
2107 if (jmp_reg_switch_backup_ctx == NULL)
2108 { // only backup when the first jmp *reg is met for restoring later, if switch mode fails to resolve RA
2109 jmp_reg_switch_backup_ctx = (struct AdvWalkContext*) alloca (sizeof (*jmp_reg_switch_backup_ctx));
2110 if (jmp_reg_switch_backup_ctx != NULL)
2111 __collector_memcpy (jmp_reg_switch_backup_ctx, cur, sizeof (*cur));
2112 DprintfT (SP_DUMP_UNWIND, "unwind.c: back up context for switch mode.\n");
2113 }
2114 }
2115 if (jmp_reg_switch_mode == 1)
2116 { // in the process of trying switch cases
2117 if (cur_jmp_reg_switch == num_jmp_reg_switch)
2118 {
2119 DprintfT (SP_DUMP_UNWIND, "unwind.c: have tried all switch with max_jmp_reg_switch_case for each\n");
2120 if (jmp_reg_switch_backup_ctx != NULL)
2121 __collector_memcpy (cur, jmp_reg_switch_backup_ctx, sizeof (*cur));
2122 int rc = process_return_real (wctx, cur, 0);
2123 if (rc == RA_SUCCESS)
2124 {
2125 if (save_ctx)
2126 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
2127 return rc;
2128 }
2129 break; // have tried all switch with max_jmp_reg_switch_case for each, goto checkFP
2130 }
2131 unsigned char *npc = jmp_reg_switch_ctx[cur_jmp_reg_switch]->pc;
2132 if (jmp_reg_switch_case == 0)
2133 // first switch case
2134 npc = check_modrm (npc); // pc next to "jmp reg" instruction
2135 else if (jmp_reg_switch_pc != NULL)
2136 npc = jmp_reg_switch_pc; // // pc next to "ret" instruction of previous case
2137 else
2138 {
2139 DprintfT (SP_DUMP_UNWIND, "unwind.c: unexpected jum switch mode situation, jmp_reg_switch_case=%d, jmp_reg_switch_pc=%p\n",
2140 jmp_reg_switch_case, jmp_reg_switch_pc);
2141 break; //goto checkFP
2142 }
2143 jmp_reg_switch_base = npc;
2144 struct AdvWalkContext *new = buf + nctx;
2145 nctx += 1;
2146 __collector_memcpy (new, jmp_reg_switch_ctx[cur_jmp_reg_switch], sizeof (*new));
2147 new->pc = npc;
2148 cur = new; /* advance the new context first */
2149 jmp_reg_switch_pc = NULL;
2150 jmp_reg_switch_case++;
2151 if (jmp_reg_switch_case == max_jmp_reg_switch_case)
2152 { // done many cases, change to another switch table
2153 cur_jmp_reg_switch++;
2154 jmp_reg_switch_case = 0;
2155 }
2156 }
2157 num_jmp_reg = 0;
2158 }
2159 if (jmp_reg_switch_mode == 1)
2160 { // when processing switch cases, check pc each time
2161 unsigned long tbgn = wctx->tbgn;
2162 unsigned long tend = wctx->tend;
2163 if ((unsigned long) (cur->pc) < tbgn || (unsigned long) (cur->pc) >= tend)
2164 {
2165 DprintfT (SP_DUMP_UNWIND, "unwind.c: pc out of range, pc=0x%lx\n", (unsigned long) (cur->pc));
2166 break;
2167 }
2168 if (jmp_reg_switch_base != NULL && cur->pc > jmp_reg_switch_base + max_switch_pc_offset)
2169 {
2170 DprintfT (SP_DUMP_UNWIND, "unwind.c: limit the walk offset after jmp reg instruction\n");
2171 if (jmp_reg_switch_backup_ctx != NULL)
2172 __collector_memcpy (cur, jmp_reg_switch_backup_ctx, sizeof (*cur));
2173 int rc = process_return_real (wctx, cur, 0);
2174 if (rc == RA_SUCCESS)
2175 {
2176 if (save_ctx)
2177 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
2178 return rc;
2179 }
2180 break; // limit the walk offset after jmp reg instruction, got checkFP
2181 }
2182 }
2183
2184 if (nctx == 0)
2185 break;
2186 // dump_targets (__LINE__, ntrg, targets);
2187 while (cur->pc > targets[cur->tidx])
2188 cur->tidx += 1;
2189 if (cur->pc == targets[cur->tidx])
2190 {
2191 /* Stop analysis. Delete context. */
2192 if (jmp_reg_switch_mode == 0 || cur->pc != jmp_reg_switch_pc_old)
2193 {
2194 if (jmp_reg_switch_mode == 1 && nctx == 1 && jmp_reg_switch_pc == NULL)
2195 {
2196 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d old target, cur->pc=%p, jmp_reg_switch_pc=%p, nctx=%d\n",
2197 __LINE__, cur->pc, jmp_reg_switch_pc, nctx);
2198 jmp_reg_switch_pc = cur->pc; // save cp before delete context, may be used as a start of switch case
2199 jmp_reg_switch_pc_old = jmp_reg_switch_pc;
2200 }
2201 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, old target.\n", __LINE__);
2202 DELETE_CURCTX ();
2203 if (cur >= buf + nctx)
2204 cur = buf;
2205 continue;
2206 }
2207 if (jmp_reg_switch_mode == 1 && cur->pc == jmp_reg_switch_pc_old)
2208 jmp_reg_switch_pc_old = NULL; // reset jmp_reg_switch_pc_old to delete the context later when cur->pc != jmp_reg_switch_pc_old
2209 }
2210
2211 /* let's walk the next x86 instruction */
2212 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d cur:%ld pc=0x%lx %02x %02x %02x %02x %02x %02x %02x sp=0x%lx\n",
2213 __LINE__, (long) (cur - buf), (unsigned long) cur->pc,
2214 (int) cur->pc[0], (int) cur->pc[1], (int) cur->pc[2],
2215 (int) cur->pc[3], (int) cur->pc[4], (int) cur->pc[5],
2216 (int) cur->pc[6], (unsigned long) cur->sp);
2217 int v = 4; /* Operand size */
2218 int a = 4; /* Address size */
2219 /* int W = 0; REX.W bit */
2220 #if WSIZE(64)
2221 int R = 0; /* REX.R bit */
2222 #endif
2223 int X = 0; /* REX.X bit */
2224 int B = 0; /* REX.B bit */
2225 /* Check prefixes */
2226 int done = 0;
2227 while (!done)
2228 {
2229 opcode = *cur->pc++;
2230 switch (opcode)
2231 {
2232 case 0x66: /* opd size override */
2233 v = 2;
2234 break;
2235 case 0x67: /*addr size override */
2236 a = 2;
2237 break;
2238 #if WSIZE(64)
2239 case 0x40: /* REX */
2240 case 0x41:
2241 case 0x42:
2242 case 0x43:
2243 case 0x44:
2244 case 0x45:
2245 case 0x46:
2246 case 0x47:
2247 case 0x48:
2248 case 0x49:
2249 case 0x4a:
2250 case 0x4b:
2251 case 0x4c:
2252 case 0x4d:
2253 case 0x4e:
2254 case 0x4f:
2255 B = (opcode & 0x1) ? 8 : 0;
2256 X = (opcode & 0x2) ? 8 : 0;
2257 R = (opcode & 0x4) ? 8 : 0;
2258 if (opcode & 0x8) /* 64 bit operand size */
2259 v = 8;
2260 opcode = *cur->pc++;
2261 done = 1;
2262 break;
2263 #endif
2264 default:
2265 done = 1;
2266 break;
2267 }
2268 }
2269 int z = (v == 8) ? 4 : v;
2270 switch (opcode)
2271 {
2272 case 0x0: /* add Eb,Gb */
2273 case 0x01: /* add Ev,Gv */
2274 case 0x02: /* add Gb,Eb */
2275 case 0x03: /* add Gv,Ev */
2276 cur->pc = check_modrm (cur->pc);
2277 break;
2278 case 0x04: /* add %al,Ib */
2279 cur->pc += 1;
2280 break;
2281 case 0x05: /* add %eax,Iz */
2282 cur->pc += z;
2283 break;
2284 case 0x06: /* push es */
2285 cur->sp -= 1;
2286 break;
2287 case 0x07: /* pop es */
2288 cur->sp += 1;
2289 if (cur->sp - RED_ZONE > cur->sp_safe)
2290 cur->sp_safe = cur->sp - RED_ZONE;
2291 break;
2292 case 0x08: /* or Eb,Gb */
2293 case 0x09: /* or Ev,Gv */
2294 case 0x0a: /* or Gb,Eb */
2295 case 0x0b: /* or Gv,Ev */
2296 cur->pc = check_modrm (cur->pc);
2297 break;
2298 case 0x0c: /* or %al,Ib */
2299 cur->pc += 1;
2300 break;
2301 case 0x0d: /* or %eax,Iz */
2302 cur->pc += z;
2303 break;
2304 case 0x0e: /* push cs */
2305 cur->sp -= 1;
2306 break;
2307 case 0x0f: /* two-byte opcodes */
2308 extop = *cur->pc++;
2309 switch (extop)
2310 { /* RTM or HLE */
2311 case 0x01:
2312 extop2 = *cur->pc;
2313 switch (extop2)
2314 {
2315 case 0xd5: /* xend */
2316 case 0xd6: /* xtest */
2317 cur->pc++;
2318 break;
2319 default:
2320 break;
2321 }
2322 break;
2323 case 0x03:
2324 cur->pc = check_modrm (cur->pc);
2325 break;
2326 case 0x0b:
2327 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, undefined instruction. opcode=0x%02x\n",
2328 __LINE__, (int) opcode);
2329 DELETE_CURCTX ();
2330 break;
2331 case 0x05: /* syscall */
2332 case 0x34: /* sysenter */
2333 if (cur->rax == __NR_exit)
2334 {
2335 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode=0x%02x\n",
2336 __LINE__, (int) opcode);
2337 DELETE_CURCTX ();
2338 break;
2339 }
2340 else if (cur->rax == __NR_rt_sigreturn)
2341 {
2342 if (jmp_reg_switch_mode == 1)
2343 {
2344 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d give up return address under jmp switch mode, opcode=0x%02x\n",
2345 __LINE__, (int) opcode);
2346 goto checkFP;
2347 }
2348 wctx->sp = (unsigned long) cur->sp;
2349 if (save_ctx)
2350 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_RT_SIGRETURN);
2351 return RA_RT_SIGRETURN;
2352 }
2353 #if WSIZE(32)
2354 else if (cur->rax == __NR_sigreturn)
2355 {
2356 if (jmp_reg_switch_mode == 1)
2357 {
2358 DprintfT (SP_DUMP_UNWIND, "unwind.c: give up return address under jmp switch mode, opcode = 0x34\n");
2359 goto checkFP;
2360 }
2361 wctx->sp = (unsigned long) cur->sp;
2362 if (save_ctx)
2363 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_SIGRETURN);
2364 return RA_SIGRETURN;
2365 }
2366 #endif
2367 /* Check for Linus' trick in the vsyscall page */
2368 while (*cur->pc == 0x90) /* nop */
2369 cur->pc++;
2370 if (*cur->pc == 0xeb) /* jmp imm8 */
2371 cur->pc += 2;
2372 break;
2373 case 0x0d: /* nop Ev */
2374 cur->pc = check_modrm (cur->pc);
2375 break;
2376 case 0x10: /* xmm Vq,Wq */
2377 case 0x11:
2378 case 0x12:
2379 case 0x13:
2380 case 0x14:
2381 case 0x15:
2382 case 0x16:
2383 case 0x17:
2384 cur->pc = check_modrm (cur->pc);
2385 break;
2386 case 0x18: /* prefetch */
2387 cur->pc = check_modrm (cur->pc);
2388 break;
2389 case 0x1E: /* endbr64/endbr32 (f3 0f 1e .. ) is parsing as repz nop edx */
2390 cur->pc += 2;
2391 break;
2392 case 0x1f: /* nop Ev */
2393 cur->pc = check_modrm (cur->pc);
2394 break;
2395 case 0x28: /* xmm Vq,Wq */
2396 case 0x29:
2397 case 0x2a:
2398 case 0x2b:
2399 case 0x2c:
2400 case 0x2d:
2401 case 0x2e:
2402 case 0x2f:
2403 cur->pc = check_modrm (cur->pc);
2404 break;
2405 case 0x30: /* wrmsr */
2406 case 0x31: /* rdtsc */
2407 case 0x32: /* rdmsr */
2408 case 0x33: /* rdpmc */
2409 break;
2410 /* case 0x34: sysenter (see above) */
2411 case 0x38: case 0x3a:
2412 extop2 = *cur->pc++;
2413 cur->pc = check_modrm (cur->pc);
2414 // 21275311 Unwind failure in native stack for java application running on jdk8
2415 // Three-byte opcodes "66 0f 3a ??" should consume an additional "immediate" byte.
2416 if (extop == 0x3a)
2417 cur->pc++;
2418 break;
2419 case 0x40: case 0x41: case 0x42: case 0x43: /* CMOVcc Gv,Ev */
2420 case 0x44: case 0x45: case 0x46: case 0x47:
2421 case 0x48: case 0x49: case 0x4a: case 0x4b:
2422 case 0x4c: case 0x4d: case 0x4e: case 0x4f:
2423 cur->pc = check_modrm (cur->pc);
2424 break;
2425 case 0x50: case 0x51: case 0x52: case 0x53:
2426 case 0x54: case 0x55: case 0x56: case 0x57:
2427 case 0x58: case 0x59: case 0x5a: case 0x5b:
2428 case 0x5c: case 0x5d: case 0x5e: case 0x5f:
2429 case 0x60: case 0x61: case 0x62: case 0x63:
2430 case 0x64: case 0x65: case 0x66: case 0x67:
2431 case 0x68: case 0x69: case 0x6a: case 0x6b:
2432 case 0x6c: case 0x6d: case 0x6e: case 0x6f:
2433 cur->pc = check_modrm (cur->pc);
2434 break;
2435 case 0x70: case 0x71: case 0x72: case 0x73:
2436 cur->pc = check_modrm (cur->pc) + 1;
2437 break;
2438 case 0x74: case 0x75: case 0x76:
2439 cur->pc = check_modrm (cur->pc);
2440 break;
2441 case 0x77:
2442 break;
2443 case 0x7c: case 0x7d: case 0x7e: case 0x7f:
2444 cur->pc = check_modrm (cur->pc);
2445 break;
2446 case 0x80: case 0x81: case 0x82: case 0x83: /* Jcc Jz */
2447 case 0x84: case 0x85: case 0x86: case 0x87:
2448 case 0x88: case 0x89: case 0x8a: case 0x8b:
2449 case 0x8c: case 0x8d: case 0x8e: case 0x8f:
2450 immv = read_int (cur->pc, z);
2451 cur->pc += z;
2452 if (nctx < (jmp_reg_switch_mode ? MAXJMPREGCTX : MAXCTX))
2453 {
2454 int tidx = 0;
2455 unsigned char *npc = cur->pc + immv;
2456 if ((unsigned long) npc < wctx->tbgn || (unsigned long) npc >= wctx->tend)
2457 {
2458 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode=0x%02x\n",
2459 __LINE__, (int) opcode);
2460 DELETE_CURCTX ();
2461 break;
2462 }
2463 if (is_after_ret (npc))
2464 break;
2465 while (npc > targets[tidx])
2466 tidx += 1;
2467 if (npc != targets[tidx])
2468 {
2469 if (ntrg < MAXTRGTS)
2470 {
2471 for (int i = 0; i < nctx; i++)
2472 if (buf[i].tidx >= tidx)
2473 buf[i].tidx++;
2474
2475 /* insert a new target */
2476 for (int i = ntrg; i > tidx; i--)
2477 targets[i] = targets[i - 1];
2478 ntrg += 1;
2479 targets[tidx++] = npc;
2480 }
2481 else
2482 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d ntrg=max(%d)\n",
2483 __LINE__, ntrg);
2484 struct AdvWalkContext *new = buf + nctx;
2485 nctx += 1;
2486 __collector_memcpy (new, cur, sizeof (*new));
2487 new->pc = npc;
2488 new->tidx = tidx;
2489 cur = new; /* advance the new context first */
2490 continue;
2491 }
2492 }
2493 else
2494 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d nctx=max(%d)\n",
2495 __LINE__, ntrg);
2496 break;
2497 case 0x90: case 0x91: case 0x92: case 0x93: /* setcc Eb */
2498 case 0x94: case 0x95: case 0x96: case 0x97:
2499 case 0x98: case 0x99: case 0x9a: case 0x9b:
2500 case 0x9c: case 0x9d: case 0x9e: case 0x9f:
2501 cur->pc = check_modrm (cur->pc);
2502 break;
2503 case 0xa0: /* push fs */
2504 cur->sp -= 1;
2505 break;
2506 case 0xa1: /* pop fs */
2507 cur->sp += 1;
2508 if (cur->sp - RED_ZONE > cur->sp_safe)
2509 cur->sp_safe = cur->sp - RED_ZONE;
2510 break;
2511 case 0xa2: /* cpuid */
2512 break;
2513 case 0xa3: /* bt Ev,Gv */
2514 cur->pc = check_modrm (cur->pc);
2515 break;
2516 case 0xa4: /* shld Ev,Gv,Ib */
2517 cur->pc = check_modrm (cur->pc);
2518 cur->pc += 1;
2519 break;
2520 case 0xa5: /* shld Ev,Gv,%cl */
2521 cur->pc = check_modrm (cur->pc);
2522 break;
2523 case 0xa8: /* push gs */
2524 cur->sp -= 1;
2525 break;
2526 case 0xa9: /* pop gs */
2527 cur->sp += 1;
2528 if (cur->sp - RED_ZONE > cur->sp_safe)
2529 cur->sp_safe = cur->sp - RED_ZONE;
2530 break;
2531 case 0xaa: /* rsm */
2532 break;
2533 case 0xab: /* bts Ev,Gv */
2534 cur->pc = check_modrm (cur->pc);
2535 break;
2536 case 0xac: /* shrd Ev,Gv,Ib */
2537 cur->pc = check_modrm (cur->pc);
2538 cur->pc += 1;
2539 break;
2540 case 0xad: /* shrd Ev,Gv,%cl */
2541 cur->pc = check_modrm (cur->pc);
2542 break;
2543 case 0xae: /* group15 */
2544 cur->pc = check_modrm (cur->pc);
2545 break;
2546 case 0xaf: /* imul Gv,Ev */
2547 cur->pc = check_modrm (cur->pc);
2548 break;
2549 case 0xb1: /* cmpxchg Ev,Gv */
2550 cur->pc = check_modrm (cur->pc);
2551 break;
2552 case 0xb3:
2553 case 0xb6: /* movzx Gv,Eb */
2554 case 0xb7: /* movzx Gv,Ew */
2555 cur->pc = check_modrm (cur->pc);
2556 break;
2557 case 0xba: /* group8 Ev,Ib */
2558 cur->pc = check_modrm (cur->pc);
2559 cur->pc += 1;
2560 break;
2561 case 0xbb: /* btc Ev,Gv */
2562 case 0xbc: /* bsf Gv,Ev */
2563 case 0xbd: /* bsr Gv,Ev */
2564 cur->pc = check_modrm (cur->pc);
2565 break;
2566 case 0xbe: /* movsx Gv,Eb */
2567 case 0xbf: /* movsx Gv,Ew */
2568 cur->pc = check_modrm (cur->pc);
2569 break;
2570 case 0xc0: /* xadd Eb,Gb */
2571 case 0xc1: /* xadd Ev,Gv */
2572 cur->pc = check_modrm (cur->pc);
2573 break;
2574 case 0xc2: /* cmpps V,W,Ib */
2575 cur->pc = check_modrm (cur->pc);
2576 cur->pc += 1;
2577 break;
2578 case 0xc3: /* movnti M,G */
2579 cur->pc = check_modrm (cur->pc);
2580 break;
2581 case 0xc6: /* shufps V,W,Ib */
2582 cur->pc = check_modrm (cur->pc);
2583 cur->pc += 1;
2584 break;
2585 case 0xc7: /* RDRAND */
2586 cur->pc = check_modrm (cur->pc);
2587 break;
2588 case 0xc8: case 0xc9: case 0xca: case 0xcb: /* bswap */
2589 case 0xcc: case 0xcd: case 0xce: case 0xcf:
2590 break;
2591 case 0xd0: case 0xd1: case 0xd2: case 0xd3:
2592 case 0xd4: case 0xd5: case 0xd6: case 0xd7:
2593 case 0xd8: case 0xd9: case 0xda: case 0xdb:
2594 case 0xdc: case 0xdd: case 0xde: case 0xdf:
2595 case 0xe0: case 0xe1: case 0xe2: case 0xe3:
2596 case 0xe4: case 0xe5: case 0xe6: case 0xe7:
2597 case 0xe8: case 0xe9: case 0xea: case 0xeb:
2598 case 0xec: case 0xed: case 0xee: case 0xef:
2599 case 0xf0: case 0xf1: case 0xf2: case 0xf3:
2600 case 0xf4: case 0xf5: case 0xf6: case 0xf7:
2601 case 0xf8: case 0xf9: case 0xfa: case 0xfb:
2602 case 0xfc: case 0xfd: case 0xfe: case 0xff:
2603 cur->pc = check_modrm (cur->pc);
2604 break;
2605 default:
2606 if (jmp_reg_switch_mode == 1 && extop == 0x0b)
2607 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d invalid opcode ub2: 0x0f %x jmp_reg_switch_mode=%d\n",
2608 __LINE__, (int) extop, jmp_reg_switch_mode);
2609 else
2610 {
2611 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d unknown opcode: 0x0f %x jmp_reg_switch_mode=%d\n",
2612 __LINE__, (int) extop, jmp_reg_switch_mode);
2613 DELETE_CURCTX ();
2614 }
2615 break;
2616 }
2617 break;
2618 case 0x10: /* adc Eb,Gb */
2619 case 0x11: /* adc Ev,Gv */
2620 case 0x12: /* adc Gb,Eb */
2621 case 0x13: /* adc Gv,Ev */
2622 cur->pc = check_modrm (cur->pc);
2623 break;
2624 case 0x14: /* adc %al,Ib */
2625 cur->pc += 1;
2626 break;
2627 case 0x15: /* adc %eax,Iz */
2628 cur->pc += z;
2629 break;
2630 case 0x16: /* push ss */
2631 cur->sp -= 1;
2632 break;
2633 case 0x17: /* pop ss */
2634 cur->sp += 1;
2635 if (cur->sp - RED_ZONE > cur->sp_safe)
2636 cur->sp_safe = cur->sp - RED_ZONE;
2637 break;
2638 case 0x18: /* sbb Eb,Gb */
2639 case 0x19: /* sbb Ev,Gv */
2640 case 0x1a: /* sbb Gb,Eb */
2641 case 0x1b: /* sbb Gv,Ev */
2642 cur->pc = check_modrm (cur->pc);
2643 break;
2644 case 0x1c: /* sbb %al,Ib */
2645 cur->pc += 1;
2646 break;
2647 case 0x1d: /* sbb %eax,Iz */
2648 cur->pc += z;
2649 break;
2650 case 0x1e: /* push ds */
2651 cur->sp -= 1;
2652 break;
2653 case 0x1f: /* pop ds */
2654 cur->sp += 1;
2655 if (cur->sp - RED_ZONE > cur->sp_safe)
2656 cur->sp_safe = cur->sp - RED_ZONE;
2657 break;
2658 case 0x20: /* and Eb,Gb */
2659 case 0x21: /* and Ev,Gv */
2660 case 0x22: /* and Gb,Eb */
2661 case 0x23: /* and Gv,Ev */
2662 cur->pc = check_modrm (cur->pc);
2663 break;
2664 case 0x24: /* and %al,Ib */
2665 cur->pc += 1;
2666 break;
2667 case 0x25: /* and %eax,Iz */
2668 cur->pc += z;
2669 break;
2670 case 0x26: /* seg=es prefix */
2671 break;
2672 case 0x27: /* daa */
2673 break;
2674 case 0x28: /* sub Eb,Gb */
2675 case 0x29: /* sub Ev,Gv */
2676 case 0x2a: /* sub Gb,Eb */
2677 case 0x2b: /* sub Gv,Ev */
2678 cur->pc = check_modrm (cur->pc);
2679 break;
2680 case 0x2c: /* sub %al,Ib */
2681 cur->pc += 1;
2682 break;
2683 case 0x2d: /* sub %eax,Iz */
2684 cur->pc += z;
2685 break;
2686 case 0x2e: /* seg=cs prefix */
2687 break;
2688 case 0x2f: /* das */
2689 break;
2690 case 0x30: /* xor Eb,Gb */
2691 case 0x31: /* xor Ev,Gv */
2692 case 0x32: /* xor Gb,Eb */
2693 case 0x33: /* xor Gv,Ev */
2694 cur->pc = check_modrm (cur->pc);
2695 break;
2696 case 0x34: /* xor %al,Ib */
2697 cur->pc += 1;
2698 break;
2699 case 0x35: /* xor %eax,Iz */
2700 cur->pc += z;
2701 break;
2702 case 0x36: /* seg=ss prefix */
2703 break;
2704 case 0x37: /* aaa */
2705 break;
2706 case 0x38: /* cmp Eb,Gb */
2707 case 0x39: /* cmp Ev,Gv */
2708 case 0x3a: /* cmp Gb,Eb */
2709 case 0x3b: /* cmp Gv,Ev */
2710 cur->pc = check_modrm (cur->pc);
2711 break;
2712 case 0x3c: /* cmp %al,Ib */
2713 cur->pc += 1;
2714 break;
2715 case 0x3d: /* cmp %eax,Iz */
2716 cur->pc += z;
2717 break;
2718 case 0x3e: /* seg=ds prefix */
2719 break;
2720 case 0x3f: /* aas */
2721 break;
2722 #if WSIZE(32)
2723 case 0x40: /* inc %eax */
2724 case 0x41: /* inc %ecx */
2725 case 0x42: /* inc %edx */
2726 case 0x43: /* inc %ebx */
2727 break;
2728 case 0x44: /* inc %esp */
2729 /* Can't be a valid stack pointer - delete context */
2730 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0x44.\n", __LINE__);
2731 DELETE_CURCTX ();
2732 break;
2733 case 0x45: /* inc %ebp */
2734 case 0x46: /* inc %esi */
2735 case 0x47: /* inc %edi */
2736 case 0x48: /* dec %eax */
2737 case 0x49: /* dec %ecx */
2738 case 0x4a: /* dec %edx */
2739 case 0x4b: /* dec %ebx */
2740 break;
2741 case 0x4c: /* dec %esp */
2742 /* Can't be a valid stack pointer - delete context */
2743 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0x4c.\n", __LINE__);
2744 DELETE_CURCTX ();
2745 break;
2746 case 0x4d: /* dec %ebp */
2747 case 0x4e: /* dec %esi */
2748 case 0x4f: /* dec %edi */
2749 break;
2750 #endif
2751 case 0x50: /* push %eax */
2752 case 0x51: /* push %ecx */
2753 case 0x52: /* push %edx */
2754 case 0x53: /* push %ebx */
2755 case 0x54: /* push %esp */
2756 case 0x55: /* push %ebp */
2757 case 0x56: /* push %esi */
2758 case 0x57: /* push %edi */
2759 cur->sp -= 1;
2760 reg = OPC_REG (opcode);
2761 if (reg == RBP)
2762 {
2763 #if 0
2764 /* Don't do this check yet. Affects tail calls. */
2765 /* avoid other function's prologue */
2766 if ((cur->pc[0] == 0x89 && cur->pc[1] == 0xe5) ||
2767 (cur->pc[0] == 0x8b && cur->pc[1] == 0xec))
2768 {
2769 /* mov %esp,%ebp */
2770 DELETE_CURCTX ();
2771 break;
2772 }
2773 #endif
2774 if (cur->fp_loc == NULL)
2775 {
2776 cur->fp_loc = cur->sp;
2777 cur->fp_sav = cur->fp;
2778 }
2779 }
2780 break;
2781 case 0x58: /* pop %eax */
2782 case 0x59: /* pop %ecx */
2783 case 0x5a: /* pop %edx */
2784 case 0x5b: /* pop %ebx */
2785 case 0x5c: /* pop %esp */
2786 case 0x5d: /* pop %ebp */
2787 case 0x5e: /* pop %esi */
2788 case 0x5f: /* pop %edi */
2789 reg = OPC_REG (opcode);
2790 cur->regs[reg] = 0;
2791 if (isInside ((unsigned long) cur->sp, (unsigned long) cur->sp_safe, wctx->sbase))
2792 cur->regs[reg] = *cur->sp;
2793 DprintfT (SP_DUMP_UNWIND, "stack_unwind:%d cur->regs[%d]=0x%lx\n",
2794 __LINE__, reg, (unsigned long) cur->regs[reg]);
2795 if (reg == RDX)
2796 {
2797 if (cur->sp >= cur->sp_safe &&
2798 (unsigned long) cur->sp < wctx->sbase)
2799 cur->rdx = *cur->sp;
2800 }
2801 else if (reg == RBP)
2802 {
2803 if (cur->fp_loc == cur->sp)
2804 {
2805 cur->fp = cur->fp_sav;
2806 cur->fp_loc = NULL;
2807 }
2808 else if (cur->sp >= cur->sp_safe &&
2809 (unsigned long) cur->sp < wctx->sbase)
2810 cur->fp = (unsigned long*) (*cur->sp);
2811 }
2812 else if (reg == RSP)
2813 {
2814 /* f.e. JVM I2CAdapter */
2815 if (cur->sp >= cur->sp_safe && (unsigned long) cur->sp < wctx->sbase)
2816 {
2817 unsigned long *nsp = (unsigned long*) (*cur->sp);
2818 if (nsp >= cur->sp && nsp <= cur->fp)
2819 {
2820 cur->sp = nsp;
2821 }
2822 else
2823 {
2824 DprintfT (SP_DUMP_UNWIND, "stack_unwind%d give up return address, opcode=0x%02x\n",
2825 __LINE__, opcode);
2826 goto checkFP;
2827 }
2828 }
2829 else
2830 {
2831 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d give up return address, opcode=0x%02x\n",
2832 __LINE__, opcode);
2833 goto checkFP;
2834 }
2835 break;
2836 }
2837 cur->sp += 1;
2838 if (cur->sp - RED_ZONE > cur->sp_safe)
2839 {
2840 cur->sp_safe = cur->sp - RED_ZONE;
2841 }
2842 break;
2843 case 0x60: /* pusha(d) */
2844 cur->sp -= 8;
2845 break;
2846 case 0x61: /* popa(d) */
2847 cur->sp += 8;
2848 if (cur->sp - RED_ZONE > cur->sp_safe)
2849 cur->sp_safe = cur->sp - RED_ZONE;
2850 break;
2851 case 0x62: /* group AVX, 4-bytes EVEX prefix */
2852 {
2853 unsigned char *pc = cur->pc - 1; // points to the beginning of the instruction
2854 int len = parse_x86_AVX_instruction (pc);
2855 if (len < 4)
2856 {
2857 DELETE_CURCTX ();
2858 }
2859 else
2860 {
2861 pc += len;
2862 cur->pc = pc;
2863 }
2864 }
2865 break;
2866 case 0x63: /* arpl Ew,Gw (32) movsxd Gv,Ev (64)*/
2867 cur->pc = check_modrm (cur->pc);
2868 break;
2869 case 0x64: /* seg=fs prefix */
2870 case 0x65: /* seg=gs prefix */
2871 break;
2872 case 0x66: /* opd size override */
2873 case 0x67: /* addr size override */
2874 break;
2875 case 0x68: /* push Iz */
2876 cur->sp = (unsigned long*) ((long) cur->sp - z);
2877 cur->pc += z;
2878 break;
2879 case 0x69: /* imul Gv,Ev,Iz */
2880 cur->pc = check_modrm (cur->pc);
2881 cur->pc += z;
2882 break;
2883 case 0x6a: /* push Ib */
2884 cur->sp = (unsigned long*) ((long) cur->sp - v);
2885 cur->pc += 1;
2886 break;
2887 case 0x6b: /* imul Gv,Ev,Ib */
2888 cur->pc = check_modrm (cur->pc);
2889 cur->pc += 1;
2890 break;
2891 case 0x6c: case 0x6d: case 0x6e: case 0x6f:
2892 cur->pc = check_modrm (cur->pc);
2893 break;
2894 case 0x70: /* jo Jb */
2895 case 0x71: /* jno Jb */
2896 case 0x72: /* jb Jb */
2897 case 0x73: /* jnb Jb */
2898 case 0x74: /* jz Jb */
2899 case 0x75: /* jnz Jb */
2900 case 0x76: /* jna Jb */
2901 case 0x77: /* ja Jb */
2902 case 0x78: /* js Jb */
2903 case 0x79: /* jns Jb */
2904 case 0x7a: /* jp Jb */
2905 case 0x7b: /* jnp Jb */
2906 case 0x7c: /* jl Jb */
2907 case 0x7d: /* jge Jb */
2908 case 0x7e: /* jle Jb */
2909 case 0x7f: /* jg Jb */
2910 imm8 = *(char*) cur->pc++;
2911 if (nctx < (jmp_reg_switch_mode ? MAXJMPREGCTX : MAXCTX))
2912 {
2913 int tidx = 0;
2914 unsigned char *npc = cur->pc + imm8;
2915 if (is_after_ret (npc))
2916 break;
2917 while (npc > targets[tidx])
2918 tidx += 1;
2919 if (npc != targets[tidx])
2920 {
2921 if (ntrg < MAXTRGTS)
2922 {
2923 for (int i = 0; i < nctx; i++)
2924 if (buf[i].tidx >= tidx)
2925 buf[i].tidx++;
2926
2927 /* insert a new target */
2928 for (int i = ntrg; i > tidx; i--)
2929 targets[i] = targets[i - 1];
2930 ntrg += 1;
2931 targets[tidx++] = npc;
2932 }
2933 else
2934 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d ntrg(%d)=max\n", __LINE__, ntrg);
2935 struct AdvWalkContext *new = buf + nctx;
2936 nctx += 1;
2937 __collector_memcpy (new, cur, sizeof (*new));
2938 new->pc = npc;
2939 new->tidx = tidx;
2940 cur = new; /* advance the new context first */
2941 continue;
2942 }
2943 }
2944 else
2945 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d nctx(%d)=max\n", __LINE__, nctx);
2946 break;
2947 case 0x80: /* group1 Eb,Ib */
2948 cur->pc = check_modrm (cur->pc);
2949 cur->pc += 1;
2950 break;
2951 case 0x81: /* group1 Ev,Iz */
2952 modrm = *cur->pc;
2953 if (MRM_MOD (modrm) == 0xc0 && MRM_REGS (modrm) == RSP)
2954 {
2955 int immz = read_int (cur->pc + 1, z);
2956 extop = MRM_EXT (modrm);
2957 if (extop == 0) /* add imm32,%esp */
2958 cur->sp = (unsigned long*) ((long) cur->sp + immz);
2959 else if (extop == 4) /* and imm32,%esp */
2960 cur->sp = (unsigned long*) ((long) cur->sp & immz);
2961 else if (extop == 5) /* sub imm32,%esp */
2962 cur->sp = (unsigned long*) ((long) cur->sp - immz);
2963 if (cur->sp - RED_ZONE > cur->sp_safe)
2964 cur->sp_safe = cur->sp - RED_ZONE;
2965 }
2966 cur->pc = check_modrm (cur->pc);
2967 cur->pc += z;
2968 break;
2969 case 0x82: /* group1 Eb,Ib */
2970 cur->pc = check_modrm (cur->pc);
2971 cur->pc += 1;
2972 break;
2973 case 0x83: /* group1 Ev,Ib */
2974 modrm = *cur->pc;
2975 if (MRM_MOD (modrm) == 0xc0 && MRM_REGS (modrm) == RSP)
2976 {
2977 imm8 = (char) cur->pc[1]; /* sign extension */
2978 extop = MRM_EXT (modrm);
2979 if (extop == 0) /* add imm8,%esp */
2980 cur->sp = (unsigned long*) ((long) cur->sp + imm8);
2981 else if (extop == 4) /* and imm8,%esp */
2982 cur->sp = (unsigned long*) ((long) cur->sp & imm8);
2983 else if (extop == 5) /* sub imm8,%esp */
2984 cur->sp = (unsigned long*) ((long) cur->sp - imm8);
2985 if (cur->sp - RED_ZONE > cur->sp_safe)
2986 cur->sp_safe = cur->sp - RED_ZONE;
2987 }
2988 cur->pc = check_modrm (cur->pc);
2989 cur->pc += 1;
2990 break;
2991 case 0x84: /* test Eb,Gb */
2992 case 0x85: /* test Ev,Gv */
2993 case 0x86: /* xchg Eb,Gb */
2994 case 0x87: /* xchg Ev,Gv */
2995 cur->pc = check_modrm (cur->pc);
2996 break;
2997 case 0x88: /* mov Eb,Gb */
2998 cur->pc = check_modrm (cur->pc);
2999 break;
3000 case 0x89: /* mov Ev,Gv */
3001 modrm = *cur->pc;
3002 if (MRM_MOD (modrm) == 0xc0)
3003 {
3004 if (MRM_REGS (modrm) == RBP && MRM_REGD (modrm) == RSP)
3005 /* movl %esp,%ebp */
3006 cur->fp = cur->sp;
3007 else if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3008 { /* mov %ebp,%esp */
3009 cur->sp = cur->fp;
3010 if (cur->sp - RED_ZONE > cur->sp_safe)
3011 cur->sp_safe = cur->sp - RED_ZONE;
3012 if (wctx->fp == (unsigned long) cur->sp)
3013 cur->cval = RA_FROMFP;
3014 }
3015 }
3016 else if (MRM_MOD (modrm) == 0x80)
3017 {
3018 if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3019 {
3020 if (cur->pc[1] == 0x24)
3021 { /* mov %ebp,disp32(%esp) - JVM */
3022 immv = read_int (cur->pc + 2, 4);
3023 cur->fp_loc = (unsigned long*) ((char*) cur->sp + immv);
3024 cur->fp_sav = cur->fp;
3025 }
3026 }
3027 }
3028 else if (MRM_MOD (modrm) == 0x40)
3029 {
3030 if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RDX)
3031 {
3032 if (cur->pc[1] == 0x24 && cur->pc[2] == 0x0)
3033 { /* movl %edx,0(%esp) */
3034 cur->ra_loc = cur->sp;
3035 cur->ra_sav = cur->rdx;
3036 }
3037 }
3038 else if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3039 {
3040 if (cur->pc[1] == 0x24)
3041 { /* mov %ebp,disp8(%esp) - JVM */
3042 imm8 = ((char*) (cur->pc))[2];
3043 cur->fp_loc = (unsigned long*) ((char*) cur->sp + imm8);
3044 cur->fp_sav = cur->fp;
3045 }
3046 }
3047 }
3048 else if (MRM_MOD (modrm) == 0x0)
3049 {
3050 if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3051 {
3052 if (cur->pc[1] == 0x24)
3053 { /* mov %ebp,(%esp) */
3054 cur->fp_loc = cur->sp;
3055 cur->fp_sav = cur->fp;
3056 }
3057 }
3058 else if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RDX)
3059 {
3060 if (cur->pc[1] == 0x24)
3061 { /* movl %edx,(%esp) */
3062 cur->ra_loc = cur->sp;
3063 cur->ra_sav = cur->rdx;
3064 }
3065 }
3066 }
3067 cur->pc = check_modrm (cur->pc);
3068 break;
3069 case 0x8a: /* mov Gb,Eb */
3070 cur->pc = check_modrm (cur->pc);
3071 break;
3072 case 0x8b: /* mov Gv,Ev */
3073 modrm = *cur->pc;
3074 if (MRM_MOD (modrm) == 0xc0)
3075 {
3076 if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3077 /* mov %esp,%ebp */
3078 cur->fp = cur->sp;
3079 else if (MRM_REGS (modrm) == RBP && MRM_REGD (modrm) == RSP)
3080 { /* mov %ebp,%esp */
3081 cur->sp = cur->fp;
3082 if (cur->sp - RED_ZONE > cur->sp_safe)
3083 cur->sp_safe = cur->sp - RED_ZONE;
3084 if (wctx->fp == (unsigned long) cur->sp)
3085 cur->cval = RA_FROMFP;
3086 }
3087 }
3088 else if (MRM_MOD (modrm) == 0x80)
3089 {
3090 if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3091 {
3092 if (cur->pc[1] == 0x24)
3093 { /* mov disp32(%esp),%ebp */
3094 immv = read_int (cur->pc + 2, 4);
3095 unsigned long *ptr = (unsigned long*) ((char*) cur->sp + immv);
3096 if (cur->fp_loc == ptr)
3097 {
3098 cur->fp = cur->fp_sav;
3099 cur->fp_loc = NULL;
3100 }
3101 else if (ptr >= cur->sp_safe && (unsigned long) ptr < wctx->sbase)
3102 cur->fp = (unsigned long*) (*ptr);
3103 }
3104 }
3105 }
3106 else if (MRM_MOD (modrm) == 0x40)
3107 {
3108 if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3109 {
3110 if (cur->pc[1] == 0x24)
3111 { /* mov disp8(%esp),%ebp - JVM */
3112 imm8 = ((char*) (cur->pc))[2];
3113 unsigned long *ptr = (unsigned long*) ((char*) cur->sp + imm8);
3114 if (cur->fp_loc == ptr)
3115 {
3116 cur->fp = cur->fp_sav;
3117 cur->fp_loc = NULL;
3118 }
3119 else if (ptr >= cur->sp_safe && (unsigned long) ptr < wctx->sbase)
3120 cur->fp = (unsigned long*) (*ptr);
3121 }
3122 }
3123 }
3124 else if (MRM_MOD (modrm) == 0x0)
3125 {
3126 if (MRM_REGS (modrm) == RSP && MRM_REGD (modrm) == RBP)
3127 {
3128 if (cur->pc[1] == 0x24)
3129 { /* mov (%esp),%ebp */
3130 if (cur->fp_loc == cur->sp)
3131 {
3132 cur->fp = cur->fp_sav;
3133 cur->fp_loc = NULL;
3134 }
3135 else if (cur->sp >= cur->sp_safe &&
3136 (unsigned long) cur->sp < wctx->sbase)
3137 cur->fp = (unsigned long*) *cur->sp;
3138 }
3139 }
3140 }
3141 cur->pc = check_modrm (cur->pc);
3142 break;
3143 case 0x8c: /* mov Mw,Sw */
3144 cur->pc = check_modrm (cur->pc);
3145 break;
3146 case 0x8d: /* lea Gv,M */
3147 modrm = *cur->pc;
3148 if (MRM_REGD (modrm) == RSP)
3149 {
3150 unsigned char *pc = cur->pc;
3151 // Mez: need to use always regs[RSP/RBP] instead cur->sp(or fp):
3152 cur->regs[RSP] = (unsigned long) cur->sp;
3153 cur->regs[RBP] = (unsigned long) cur->fp;
3154 cur->pc++;
3155 int mod = (modrm >> 6) & 3;
3156 int r_m = modrm & 7;
3157 long val = 0;
3158 int undefRez = 0;
3159 if (mod == 0x3)
3160 val = getRegVal (cur, MRM_REGS (modrm), &undefRez);
3161 else if (r_m == 4)
3162 { // SP or R12. Decode SIB-byte.
3163 int sib = *cur->pc++;
3164 int scale = 1 << (sib >> 6);
3165 int index = X | ((sib >> 3) & 7);
3166 int base = B | (sib & 7);
3167 if (mod == 0)
3168 {
3169 if ((base & 7) == 5)
3170 { // BP or R13
3171 if (index != 4) // SP
3172 val += getRegVal (cur, index, &undefRez) * scale;
3173 val += read_int (cur->pc, 4);
3174 cur->pc += 4;
3175 }
3176 else
3177 {
3178 val += getRegVal (cur, base, &undefRez);
3179 if (index != 4) // SP
3180 val += getRegVal (cur, index, &undefRez) * scale;
3181 }
3182 }
3183 else
3184 {
3185 val += getRegVal (cur, base, &undefRez);
3186 if (index != 4) // SP
3187 val += getRegVal (cur, index, &undefRez) * scale;
3188 if (mod == 1)
3189 {
3190 val += read_int (cur->pc, 1);
3191 cur->pc++;
3192 }
3193 else
3194 { // mod == 2
3195 val += read_int (cur->pc, 4);
3196 cur->pc += 4;
3197 }
3198 }
3199 }
3200 else if (mod == 0)
3201 {
3202 if (r_m == 5)
3203 { // BP or R13
3204 val += read_int (cur->pc, 4);
3205 cur->pc += 4;
3206 }
3207 else
3208 val += getRegVal (cur, MRM_REGS (modrm), &undefRez);
3209 }
3210 else
3211 { // mod == 1 || mod == 2
3212 val += getRegVal (cur, MRM_REGS (modrm), &undefRez);
3213 if (mod == 1)
3214 {
3215 val += read_int (cur->pc, 1);
3216 cur->pc++;
3217 }
3218 else
3219 { // mod == 2
3220 val += read_int (cur->pc, 4);
3221 cur->pc += 4;
3222 }
3223 }
3224 if (undefRez)
3225 {
3226 DprintfT (SP_DUMP_UNWIND, "stack_unwind%d cannot calculate RSP. cur->pc=0x%lx val=0x%lx\n",
3227 __LINE__, (unsigned long) cur->pc, (unsigned long) val);
3228 goto checkFP;
3229 }
3230 cur->regs[MRM_REGD (modrm)] = val;
3231 DprintfT (SP_DUMP_UNWIND, "stack_unwind%d cur->pc=0x%lx val=0x%lx wctx->sp=0x%lx wctx->sbase=0x%lx\n",
3232 __LINE__, (unsigned long) cur->pc, (unsigned long) val,
3233 (unsigned long) wctx->sp, (unsigned long) wctx->sbase);
3234 if (cur->pc != check_modrm (pc))
3235 DprintfT (SP_DUMP_UNWIND, "stack_unwind%d ERROR: cur->pc=0x%lx != check_modrm(0x%lx)=0x%lx\n",
3236 __LINE__, (unsigned long) cur->pc, (unsigned long) pc,
3237 (unsigned long) check_modrm (pc));
3238 if (MRM_REGD (modrm) == RSP)
3239 {
3240 if (!isInside ((unsigned long) val, wctx->sp, wctx->sbase))
3241 {
3242 DprintfT (SP_DUMP_UNWIND, "stack_unwind%d cannot calculate RSP. cur->pc=0x%lx opcode=0x%02x val=0x%lx wctx->sp=0x%lx wctx->sbase=0x%lx\n",
3243 __LINE__, (unsigned long) cur->pc, opcode, (unsigned long) val,
3244 (unsigned long) wctx->sp, (unsigned long) wctx->sbase);
3245 goto checkFP;
3246 }
3247 cur->sp = (unsigned long *) val;
3248 if (cur->sp - RED_ZONE > cur->sp_safe)
3249 cur->sp_safe = cur->sp - RED_ZONE;
3250 }
3251 }
3252 else
3253 cur->pc = check_modrm (cur->pc);
3254 break;
3255 case 0x8e: /* mov Sw,Ew */
3256 cur->pc = check_modrm (cur->pc);
3257 break;
3258 case 0x8f: /* pop Ev */
3259 cur->pc = check_modrm (cur->pc);
3260 cur->sp += 1;
3261 if (cur->sp - RED_ZONE > cur->sp_safe)
3262 cur->sp_safe = cur->sp - RED_ZONE;
3263 break;
3264 case 0x90: /* nop */
3265 break;
3266 case 0x91: /* xchg %eax,%ecx */
3267 case 0x92: /* xchg %eax,%edx */
3268 case 0x93: /* xchg %eax,%ebx */
3269 case 0x94: /* xchg %eax,%esp XXXX */
3270 case 0x95: /* xchg %eax,%ebp XXXX */
3271 case 0x96: /* xchg %eax,%esi */
3272 case 0x97: /* xchg %eax,%edi */
3273 break;
3274 case 0x98: /* cbw/cwde */
3275 case 0x99: /* cwd/cwq */
3276 break;
3277 case 0x9a: /* callf Ap */
3278 if (jmp_reg_switch_mode == 1)
3279 {
3280 struct AdvWalkContext* tmpctx = (struct AdvWalkContext *) alloca (sizeof (*cur));
3281 __collector_memcpy (tmpctx, cur, sizeof (*cur));
3282 int rc = process_return (wctx, tmpctx);
3283 if (rc != RA_FAILURE)
3284 {
3285 if (save_ctx)
3286 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3287 return rc;
3288 }
3289 }
3290 cur->pc += 2 + a;
3291 break;
3292 case 0x9b: /* fwait */
3293 case 0x9c: /* pushf Fv */
3294 case 0x9d: /* popf Fv */
3295 case 0x9e: /* sahf */
3296 case 0x9f: /* lahf */
3297 break;
3298 case 0xa0: /* mov al,Ob */
3299 case 0xa1: /* mov eax,Ov */
3300 case 0xa2: /* mov Ob,al */
3301 case 0xa3: /* mov Ov,eax */
3302 cur->pc += a;
3303 break;
3304 case 0xa4: /* movsb Yb,Xb */
3305 case 0xa5: /* movsd Yv,Xv */
3306 case 0xa6: /* cmpsb Yb,Xb */
3307 case 0xa7: /* cmpsd Xv,Yv */
3308 break;
3309 case 0xa8: /* test al,Ib */
3310 cur->pc += 1;
3311 break;
3312 case 0xa9: /* test eax,Iz */
3313 cur->pc += z;
3314 break;
3315 case 0xaa: /* stosb Yb,%al */
3316 case 0xab: /* stosd Yv,%eax */
3317 case 0xac: /* lodsb %al,Xb */
3318 case 0xad: /* lodsd %eax,Xv */
3319 case 0xae: /* scasb %al,Yb */
3320 case 0xaf: /* scasd %eax,Yv */
3321 break;
3322 case 0xb0: /* mov %al,Ib */
3323 case 0xb1: /* mov %cl,Ib */
3324 case 0xb2: /* mov %dl,Ib */
3325 case 0xb3: /* mov %bl,Ib */
3326 case 0xb4: /* mov %ah,Ib */
3327 case 0xb5: /* mov %ch,Ib */
3328 case 0xb6: /* mov %dh,Ib */
3329 case 0xb7: /* mov %bh,Ib */
3330 cur->pc += 1;
3331 break;
3332 case 0xb8: /* mov Iv,%eax */
3333 case 0xb9: /* mov Iv,%ecx */
3334 case 0xba: /* mov Iv,%edx */
3335 case 0xbb: /* mov Iv,%ebx */
3336 case 0xbc: /* mov Iv,%esp */
3337 case 0xbd: /* mov Iv,%rbp */
3338 case 0xbe: /* mov Iv,%esi */
3339 case 0xbf: /* mov Iv,%edi */
3340 reg = OPC_REG (opcode);
3341 if (reg == RAX)
3342 cur->rax = read_int (cur->pc, v);
3343 cur->pc += v;
3344 break;
3345 case 0xc0: /* group2 Eb,Ib */
3346 case 0xc1: /* group2 Ev,Ib */
3347 cur->pc = check_modrm (cur->pc) + 1;
3348 break;
3349 case 0xc2: /* ret Iw */
3350 /* In the dynamic linker we may see that
3351 * the actual return address is at sp+immv,
3352 * while sp points to the resolved address.
3353 */
3354 {
3355 immv = read_int (cur->pc, 2);
3356 int rc = process_return (wctx, cur);
3357 if (rc != RA_FAILURE)
3358 {
3359 if (jmp_reg_switch_mode == 1)
3360 {
3361 DprintfT (SP_DUMP_UNWIND, "stack_unwind%d give up return address under jmp switch mode, opcode = 0xc2\n", __LINE__);
3362 goto checkFP;
3363 }
3364 wctx->sp += immv;
3365 if (save_ctx)
3366 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3367 return rc;
3368 }
3369 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0xc2.\n", __LINE__);
3370 DELETE_CURCTX ();
3371 }
3372 break;
3373 case 0xc3: /* ret */
3374 {
3375 int rc = process_return (wctx, cur);
3376 if (rc != RA_FAILURE)
3377 {
3378 if (save_ctx)
3379 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3380 return rc;
3381 }
3382 if (jmp_reg_switch_mode == 1)
3383 jmp_reg_switch_pc = cur->pc;
3384 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0xc3.\n", __LINE__);
3385 DELETE_CURCTX ();
3386 }
3387 break;
3388 case 0xc4: /* group AVX, 3-bytes VEX prefix */
3389 {
3390 unsigned char *pc = cur->pc - 1; // points to the beginning of the instruction
3391 int len = parse_x86_AVX_instruction (pc);
3392 if (len < 3)
3393 DELETE_CURCTX ();
3394 else
3395 {
3396 pc += len;
3397 cur->pc = pc;
3398 }
3399 }
3400 break;
3401 case 0xc5: /* group AVX, 2-bytes VEX prefix */
3402 {
3403 unsigned char *pc = cur->pc - 1; // points to the beginning of the instruction
3404 int len = parse_x86_AVX_instruction (pc);
3405 if (len < 2)
3406 DELETE_CURCTX ();
3407 else
3408 {
3409 pc += len;
3410 cur->pc = pc;
3411 }
3412 }
3413 break;
3414 case 0xc6:
3415 modrm = *cur->pc;
3416 if (modrm == 0xf8) /* xabort */
3417 cur->pc += 2;
3418 else /* mov Eb,Ib */
3419 cur->pc = check_modrm (cur->pc) + 1;
3420 break;
3421 case 0xc7:
3422 modrm = *cur->pc;
3423 if (modrm == 0xf8) /* xbegin */
3424 cur->pc += v + 1;
3425 else
3426 { /* mov Ev,Iz */
3427 extop = MRM_EXT (modrm);
3428 if (extop != 0)
3429 {
3430 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d give up return address, opcode = 0xc7\n", __LINE__);
3431 goto checkFP;
3432 }
3433 if (MRM_MOD (modrm) == 0xc0 && MRM_REGS (modrm) == RAX)
3434 cur->rax = read_int (cur->pc + 1, z);
3435 cur->pc = check_modrm (cur->pc) + z;
3436 }
3437 break;
3438 case 0xc8: /* enter Iw,Ib */
3439 cur->pc += 3;
3440 break;
3441 case 0xc9: /* leave */
3442 /* mov %ebp,%esp */
3443 cur->sp = cur->fp;
3444 /* pop %ebp */
3445 if (cur->fp_loc == cur->sp)
3446 {
3447 cur->fp = cur->fp_sav;
3448 cur->fp_loc = NULL;
3449 }
3450 else if (cur->sp >= cur->sp_safe &&
3451 (unsigned long) cur->sp < wctx->sbase)
3452 {
3453 cur->fp = (unsigned long*) (*cur->sp);
3454 if (wctx->fp == (unsigned long) cur->sp)
3455 cur->cval = RA_FROMFP;
3456 }
3457 cur->sp += 1;
3458 if (cur->sp - RED_ZONE > cur->sp_safe)
3459 cur->sp_safe = cur->sp - RED_ZONE;
3460 break;
3461 case 0xca: /* retf Iw */
3462 cur->pc += 2; /* XXXX process return */
3463 break;
3464 case 0xcb: /* retf */
3465 break; /* XXXX process return */
3466 case 0xcc: /* int 3 */
3467 break;
3468 case 0xcd: /* int Ib */
3469 if (*cur->pc == 0x80)
3470 {
3471 if (cur->rax == __NR_exit)
3472 {
3473 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0xcd.\n", __LINE__);
3474 DELETE_CURCTX ();
3475 break;
3476 }
3477 else if (cur->rax == __NR_rt_sigreturn)
3478 {
3479 if (jmp_reg_switch_mode == 1)
3480 {
3481 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d give up return address under jmp switch mode, opcode=0xcd\n",
3482 __LINE__);
3483 goto checkFP;
3484 }
3485 wctx->sp = (unsigned long) cur->sp;
3486 if (save_ctx)
3487 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_RT_SIGRETURN);
3488 return RA_RT_SIGRETURN;
3489 }
3490 #if WSIZE(32)
3491 else if (cur->rax == __NR_sigreturn)
3492 {
3493 if (jmp_reg_switch_mode == 1)
3494 {
3495 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d give up return address under jmp switch mode, opcode = 0xc2\n",
3496 __LINE__);
3497 goto checkFP;
3498 }
3499 wctx->sp = (unsigned long) cur->sp;
3500 if (save_ctx)
3501 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_SIGRETURN);
3502 return RA_SIGRETURN;
3503 }
3504 #endif
3505 }
3506 cur->pc += 1;
3507 break;
3508 case 0xce: /* into */
3509 case 0xcf: /* iret */
3510 break;
3511 case 0xd0: /* shift group2 Eb,1 */
3512 case 0xd1: /* shift group2 Ev,1 */
3513 case 0xd2: /* shift group2 Eb,%cl */
3514 case 0xd3: /* shift group2 Ev,%cl */
3515 cur->pc = check_modrm (cur->pc);
3516 break;
3517 case 0xd4: /* aam Ib */
3518 cur->pc += 1;
3519 break;
3520 case 0xd5: /* aad Ib */
3521 cur->pc += 1;
3522 break;
3523 case 0xd6: /* falc? */
3524 break;
3525 case 0xd7:
3526 cur->pc = check_modrm (cur->pc);
3527 cur->pc++;
3528 break;
3529 case 0xd8: /* esc instructions */
3530 case 0xd9:
3531 case 0xda:
3532 case 0xdb:
3533 case 0xdc:
3534 case 0xdd:
3535 case 0xde:
3536 case 0xdf:
3537 cur->pc = check_modrm (cur->pc);
3538 break;
3539 case 0xe0: /* loopne Jb */
3540 case 0xe1: /* loope Jb */
3541 case 0xe2: /* loop Jb */
3542 case 0xe3: /* jcxz Jb */
3543 imm8 = *(char*) cur->pc++;
3544 if (nctx < (jmp_reg_switch_mode ? MAXJMPREGCTX : MAXCTX))
3545 {
3546 int tidx = 0;
3547 unsigned char *npc = cur->pc + imm8;
3548 if (is_after_ret (npc))
3549 break;
3550 while (npc > targets[tidx])
3551 tidx += 1;
3552 if (npc != targets[tidx])
3553 {
3554 if (ntrg < MAXTRGTS)
3555 {
3556 for (int i = 0; i < nctx; i++)
3557 if (buf[i].tidx >= tidx)
3558 buf[i].tidx++;
3559 /* insert a new target */
3560 for (int i = ntrg; i > tidx; i--)
3561 targets[i] = targets[i - 1];
3562 ntrg += 1;
3563 targets[tidx++] = npc;
3564 }
3565 else
3566 DprintfT (SP_DUMP_UNWIND, "unwind.c: ntrg = max\n");
3567 struct AdvWalkContext *new = buf + nctx;
3568 nctx += 1;
3569 __collector_memcpy (new, cur, sizeof (*new));
3570 new->pc = npc;
3571 new->tidx = tidx;
3572 cur = new; /* advance the new context first */
3573 continue;
3574 }
3575 }
3576 else
3577 DprintfT (SP_DUMP_UNWIND, "unwind.c: nctx = max\n");
3578 break;
3579 case 0xe4: case 0xe5:
3580 cur->pc = check_modrm (cur->pc);
3581 cur->pc++;
3582 break;
3583 case 0xe6: case 0xe7:
3584 cur->pc++;
3585 cur->pc = check_modrm (cur->pc);
3586 break;
3587 case 0xec: case 0xed: case 0xee: case 0xef:
3588 cur->pc = check_modrm (cur->pc);
3589 break;
3590 case 0xe8: /* call Jz (f64) */
3591 {
3592 if (jmp_reg_switch_mode == 1)
3593 {
3594 struct AdvWalkContext* tmpctx = (struct AdvWalkContext *) alloca (sizeof (*cur));
3595 __collector_memcpy (tmpctx, cur, sizeof (*cur));
3596 int rc = process_return (wctx, tmpctx);
3597 if (rc != RA_FAILURE)
3598 {
3599 if (save_ctx)
3600 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3601 return rc;
3602 }
3603 }
3604 int immz = read_int (cur->pc, z);
3605 if (immz == 0)
3606 /* special case in PIC code */
3607 cur->sp -= 1;
3608 cur->pc += z;
3609 }
3610 break;
3611 case 0xe9: /* jump Jz */
3612 {
3613 int immz = read_int (cur->pc, z);
3614 unsigned char *npc = cur->pc + z + immz;
3615 if ((unsigned long) npc < wctx->tbgn || (unsigned long) npc >= wctx->tend)
3616 {
3617 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0xe9.\n", __LINE__);
3618 DELETE_CURCTX ();
3619 break;
3620 }
3621 int tidx = 0;
3622 while (npc > targets[tidx])
3623 tidx += 1;
3624 if (npc != targets[tidx])
3625 {
3626 if (ntrg < MAXTRGTS)
3627 {
3628 for (int i = 0; i < nctx; i++)
3629 if (buf[i].tidx >= tidx)
3630 buf[i].tidx++;
3631 /* insert a new target */
3632 for (int i = ntrg; i > tidx; i--)
3633 targets[i] = targets[i - 1];
3634 ntrg += 1;
3635 targets[tidx++] = npc;
3636 }
3637 else
3638 DprintfT (SP_DUMP_UNWIND, "unwind.c: ntrg = max\n");
3639 cur->pc = npc;
3640 cur->tidx = tidx;
3641 continue; /* advance this context first */
3642 }
3643 else
3644 {
3645 /* Delete context */
3646 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0xe9.\n", __LINE__);
3647 DELETE_CURCTX ();
3648 }
3649 }
3650 break;
3651 case 0xeb: /* jump imm8 */
3652 {
3653 imm8 = *(char*) cur->pc++;
3654 int tidx = 0;
3655 unsigned char *npc = cur->pc + imm8;
3656 while (npc > targets[tidx])
3657 tidx += 1;
3658 if (npc != targets[tidx])
3659 {
3660 if (ntrg < MAXTRGTS)
3661 {
3662 for (int i = 0; i < nctx; i++)
3663 if (buf[i].tidx >= tidx)
3664 buf[i].tidx++;
3665 /* insert a new target */
3666 for (int i = ntrg; i > tidx; i--)
3667 targets[i] = targets[i - 1];
3668 ntrg += 1;
3669 targets[tidx++] = npc;
3670 }
3671 else
3672 DprintfT (SP_DUMP_UNWIND, "unwind.c: ntrg = max\n");
3673 cur->pc = npc;
3674 cur->tidx = tidx;
3675 continue; /* advance this context first */
3676 }
3677 else
3678 {
3679 /* Delete context */
3680 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0xeb.\n", __LINE__);
3681 DELETE_CURCTX ();
3682 }
3683 }
3684 break;
3685 case 0xf0: /* lock prefix */
3686 case 0xf2: /* repne prefix */
3687 case 0xf3: /* repz prefix */
3688 break;
3689 case 0xf4: /* hlt */
3690 extop2 = *(cur->pc - 3);
3691 if (extop2 == 0x90)
3692 {
3693 // 17851712 occasional SEGV in find_i386_ret_addr in unwind.c during attach
3694 if (save_ctx)
3695 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_END_OF_STACK);
3696 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d returns RA_END_OF_STACK\n", __LINE__);
3697 return RA_END_OF_STACK;
3698 }
3699 /* We see 'hlt' in _start. Stop analysis, revert to FP */
3700 /* A workaround for the Linux main stack */
3701 if (nctx > 1)
3702 {
3703 DELETE_CURCTX ();
3704 break;
3705 }
3706 if (cur->fp == 0)
3707 {
3708 if (jmp_reg_switch_mode == 1)
3709 {
3710 DprintfT (SP_DUMP_UNWIND, "unwind.c: give up return address under jmp switch mode, opcode = 0xf4\n");
3711 goto checkFP;
3712 }
3713 cache_put (wctx, RA_EOSTCK);
3714 wctx->pc = 0;
3715 wctx->sp = 0;
3716 wctx->fp = 0;
3717 if (save_ctx)
3718 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_END_OF_STACK);
3719 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d returns RA_END_OF_STACK\n", __LINE__);
3720 return RA_END_OF_STACK;
3721 }
3722 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d give up return address, opcode = 0xf4\n", __LINE__);
3723 goto checkFP;
3724 case 0xf5: /* cmc */
3725 break;
3726 case 0xf6: /* group3 Eb */
3727 modrm = *cur->pc;
3728 extop = MRM_EXT (modrm);
3729 cur->pc = check_modrm (cur->pc);
3730 if (extop == 0x0) /* test Ib */
3731 cur->pc += 1;
3732 break;
3733 case 0xf7: /* group3 Ev */
3734 modrm = *cur->pc;
3735 extop = MRM_EXT (modrm);
3736 cur->pc = check_modrm (cur->pc);
3737 if (extop == 0x0) /* test Iz */
3738 cur->pc += z;
3739 break;
3740 case 0xf8: /* clc */
3741 case 0xf9: /* stc */
3742 case 0xfa: /* cli */
3743 case 0xfb: /* sti */
3744 case 0xfc: /* cld */
3745 case 0xfd: /* std */
3746 break;
3747 case 0xfe: /* group4 */
3748 modrm = *cur->pc;
3749 extop = MRM_EXT (modrm);
3750 switch (extop)
3751 {
3752 case 0x0: /* inc Eb */
3753 case 0x1: /* dec Eb */
3754 cur->pc = check_modrm (cur->pc);
3755 break;
3756 case 0x7:
3757 cur->pc = check_modrm (cur->pc);
3758 break;
3759 default:
3760 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d unknown opcode: 0xfe %x\n",
3761 __LINE__, extop);
3762 DELETE_CURCTX ();
3763 break;
3764 }
3765 break;
3766 case 0xff: /* group5 */
3767 modrm = *cur->pc;
3768 extop = MRM_EXT (modrm);
3769 switch (extop)
3770 {
3771 case 0x0: /* inc Ev */
3772 case 0x1: /* dec Ev */
3773 cur->pc = check_modrm (cur->pc);
3774 break;
3775 case 0x2: /* calln Ev */
3776 if (jmp_reg_switch_mode == 1)
3777 {
3778 struct AdvWalkContext* tmpctx = (struct AdvWalkContext *) alloca (sizeof (*cur));
3779 __collector_memcpy (tmpctx, cur, sizeof (*cur));
3780 int rc = process_return (wctx, tmpctx);
3781 if (rc != RA_FAILURE)
3782 {
3783 if (save_ctx)
3784 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3785 return rc;
3786 }
3787 }
3788 cur->pc = check_modrm (cur->pc);
3789 break;
3790 case 0x3: /* callf Ep */
3791 if (jmp_reg_switch_mode == 1)
3792 {
3793 struct AdvWalkContext* tmpctx = (struct AdvWalkContext *) alloca (sizeof (*cur));
3794 __collector_memcpy (tmpctx, cur, sizeof (*cur));
3795 int rc = process_return (wctx, tmpctx);
3796 if (rc != RA_FAILURE)
3797 {
3798 if (save_ctx)
3799 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3800 return rc;
3801 }
3802 }
3803 cur->pc = check_modrm (cur->pc); /* XXXX */
3804 break;
3805 case 0x4: /* jumpn Ev */
3806 /* This instruction appears in PLT or
3807 * in tail call optimization.
3808 * In both cases treat it as return.
3809 * Save jump *(reg) - switch, etc, for later use when no ctx left
3810 */
3811 if (modrm == 0x25 || /* jumpn *disp32 */
3812 MRM_MOD (modrm) == 0x40 || /* jumpn byte(reg) */
3813 MRM_MOD (modrm) == 0x80) /* jumpn word(reg) */
3814 {
3815 DprintfT (SP_DUMP_UNWIND, "unwind.c: PLT or tail call: %p\n", cur->pc - 1);
3816 int rc = process_return (wctx, cur);
3817 if (rc != RA_FAILURE)
3818 {
3819 if (jmp_reg_switch_mode == 1 && total_num_jmp_reg < max_num_jmp_reg_seen)
3820 {
3821 DprintfT (SP_DUMP_UNWIND, "unwind.c: give up return address under jmp switch mode, opcode = 0xff\n");
3822 goto checkFP;
3823 }
3824 if (save_ctx)
3825 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3826 return rc;
3827 }
3828 }
3829 else if (modrm != 0x24 /*ignore SIB*/) /* jumpn *(reg) or jumpn reg */
3830 {
3831 // 22846120 stack unwind does not find caller of __memcpy_ssse3_back with B64 intel-Linux
3832 /*
3833 * For now, let's deal rather narrowly with this scenario. If:
3834 * - we are in the middle of an "ff e2" instruction, and
3835 * - the next instruction is undefined ( 0f 0b == ud2 )
3836 * then test return. (Might eventually have to broaden the scope
3837 * of this fix to other registers/etc.)
3838 */
3839 if (cur->pc[0] == 0xe2 && cur->pc[1] == 0x0f && cur->pc[2] == 0x0b)
3840 {
3841 int rc = process_return_real (wctx, cur, 0);
3842 if (rc == RA_SUCCESS)
3843 {
3844 if (save_ctx)
3845 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3846 return rc;
3847 }
3848 }
3849
3850 // 22691241 shjsynprog, jsynprog core dump from find_i386_ret_addr
3851 /*
3852 * Here is another oddity. Java 9 seems to emit dynamically generated
3853 * code where a code block ends with a "jmp *reg" and then padding to a
3854 * multiple-of-16 boundary and then a bunch of 0s. In this case, let's
3855 * not continue to walk bytes since we would be walking off the end of
3856 * the instructions into ... something. Treating them as instructions
3857 * can lead to unexpected results, including SEGV.
3858 */
3859 /*
3860 * While the general problem deserves a better solution, let's look
3861 * here only for one particular case:
3862 * 0xff 0xe7 jmp *reg
3863 * nop to bring us to a multiple-of-16 boundary
3864 * 0x0000000000000a00 something that does not look like an instruction
3865 *
3866 * A different nop might be used depending on how much padding is needed
3867 * to reach that multiple-of-16 boundary. We've seen two:
3868 * 0x90 one byte
3869 * 0x0f 0x1f 0x40 0x00 four bytes
3870 */
3871 // confirm the instruction is 0xff 0xe7
3872 if (cur->pc[0] == 0xe7)
3873 {
3874 // check for correct-length nop and find next 16-byte boundary
3875 int found_nop = 0;
3876 unsigned long long *boundary = 0;
3877 switch ((((unsigned long) (cur->pc)) & 0xf))
3878 {
3879 case 0xb: // look for 4-byte nop
3880 if (*((unsigned *) (cur->pc + 1)) == 0x00401f0f)
3881 found_nop = 1;
3882 boundary = (unsigned long long *) (cur->pc + 5);
3883 break;
3884 case 0xe: // look for 1-byte nop
3885 if (cur->pc[1] == 0x90)
3886 found_nop = 1;
3887 boundary = (unsigned long long *) (cur->pc + 2);
3888 break;
3889 default:
3890 break;
3891 }
3892
3893 // if nop is found, check what's at the boundary
3894 if (found_nop && *boundary == 0x000000000a00)
3895 {
3896 DELETE_CURCTX ();
3897 break;
3898 }
3899 }
3900
3901 DprintfT (SP_DUMP_UNWIND, "unwind.c: probably PLT or tail call or switch table: %p\n",
3902 cur->pc - 1);
3903 if (num_jmp_reg < expected_num_jmp_reg)
3904 {
3905 if (jmp_reg_ctx[num_jmp_reg] == NULL)
3906 jmp_reg_ctx[num_jmp_reg] = (struct AdvWalkContext *) alloca (sizeof (*cur));
3907 if (jmp_reg_ctx[num_jmp_reg] != NULL)
3908 __collector_memcpy (jmp_reg_ctx[num_jmp_reg], cur, sizeof (*cur));
3909 }
3910 if (num_jmp_reg < expected_num_jmp_reg ||
3911 (num_jmp_reg >= expected_num_jmp_reg &&
3912 jmp_reg_ctx[expected_num_jmp_reg - 1] != NULL &&
3913 cur->pc != jmp_reg_ctx[expected_num_jmp_reg - 1]->pc))
3914 {
3915 num_jmp_reg++;
3916 total_num_jmp_reg++;
3917 }
3918 if (jmp_reg_switch_mode == 1 && total_num_jmp_reg >= max_num_jmp_reg_seen)
3919 {
3920 int rc = process_return_real (wctx, cur, 0);
3921 if (rc == RA_SUCCESS)
3922 {
3923 if (save_ctx)
3924 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3925 return rc;
3926 }
3927 }
3928 }
3929 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d delete context, opcode 0xff.\n", __LINE__);
3930 DELETE_CURCTX ();
3931 break;
3932 case 0x5: /* jmpf Ep */
3933 cur->pc = check_modrm (cur->pc); /* XXXX */
3934 break;
3935 case 0x6: /* push Ev */
3936 cur->pc = check_modrm (cur->pc);
3937 cur->sp -= 1;
3938 break;
3939 case 0x7:
3940 cur->pc = check_modrm (cur->pc); /* XXXX */
3941 if (jmp_reg_switch_mode == 1)
3942 {
3943 int rc = process_return_real (wctx, cur, 0);
3944 if (rc == RA_SUCCESS)
3945 {
3946 if (save_ctx)
3947 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, rc);
3948 return rc;
3949 }
3950 }
3951 break;
3952 default:
3953 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d unknown opcode: 0xff %x\n",
3954 __LINE__, (int) extop);
3955 DELETE_CURCTX ();
3956 break;
3957 }
3958 break;
3959 default:
3960 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d unknown opcode: 0x%x\n",
3961 __LINE__, (int) opcode);
3962 DELETE_CURCTX ();
3963 break;
3964 }
3965
3966 /* switch to next context */
3967 if (++cur >= buf + nctx)
3968 cur = buf;
3969 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d switch context: cur=0x%lx(%ld) nctx=%d cnt=%d\n",
3970 __LINE__, (unsigned long) cur, (long) (cur - buf), (int) nctx, (int) cnt);
3971 }
3972
3973 checkFP:
3974 Tprintf (DBG_LT3, "find_i386_ret_addr:%d checkFP: wctx=0x%lx fp=0x%lx ln=0x%lx pc=0x%lx sbase=0x%lx sp=0x%lx tbgn=0x%lx tend=0x%lx\n",
3975 __LINE__, (unsigned long) wctx, (unsigned long) wctx->fp,
3976 (unsigned long) wctx->ln, (unsigned long) wctx->pc, (unsigned long) wctx->sbase,
3977 (unsigned long) wctx->sp, (unsigned long) wctx->tbgn, (unsigned long) wctx->tend);
3978
3979 if (jmp_reg_switch_mode == 1)
3980 { // not deal with switch cases not ending with ret
3981 if (jmp_reg_switch_backup_ctx != NULL)
3982 __collector_memcpy (cur, jmp_reg_switch_backup_ctx, sizeof (*cur));
3983 DprintfT (SP_DUMP_UNWIND, "stack_unwind jmp reg mode on: pc = 0x%lx cnt = %d, nctx = %d\n", wctx->pc, cnt, nctx);
3984 }
3985
3986 unsigned long *cur_fp = cur->fp;
3987 unsigned long *cur_sp = cur->sp;
3988 if (do_walk == 0)
3989 __collector_memcpy (&wctx_pc_save, wctx, sizeof (struct WalkContext));
3990
3991 /* Resort to the frame pointer */
3992 if (cur->fp_loc)
3993 cur->fp = cur->fp_sav;
3994 cur->sp = cur->fp;
3995 if ((unsigned long) cur->sp >= wctx->sbase ||
3996 (unsigned long) cur->sp < wctx->sp)
3997 {
3998 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d do_walk=%d cur->sp=0x%p out of range. wctx->sbase=0x%lx wctx->sp=0x%lx wctx->pc=0x%lx\n",
3999 __LINE__, (int) do_walk, cur->sp, (unsigned long) wctx->sbase,
4000 (unsigned long) wctx->sp, (unsigned long) wctx->pc);
4001 if (do_walk == 0)
4002 {
4003 cur->sp = cur_sp;
4004 cur->fp = cur_fp;
4005 do_walk = 1;
4006 save_ctx = 1;
4007 goto startWalk;
4008 }
4009 if (save_ctx)
4010 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_FAILURE);
4011 return RA_FAILURE;
4012 }
4013
4014 unsigned long fp = *cur->sp++;
4015 if (fp <= (unsigned long) cur->sp || fp >= wctx->sbase)
4016 {
4017 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d fp=0x%016llx out of range. cur->sp=%p wctx->sbase=0x%lx wctx->pc=0x%lx\n",
4018 __LINE__, (unsigned long long) fp, cur->sp,
4019 (unsigned long) wctx->sbase, (unsigned long) wctx->pc);
4020 if (do_walk == 0)
4021 {
4022 cur->sp = cur_sp;
4023 cur->fp = cur_fp;
4024 do_walk = 1;
4025 save_ctx = 1;
4026 goto startWalk;
4027 }
4028 if (save_ctx)
4029 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_FAILURE);
4030 return RA_FAILURE;
4031 }
4032
4033 unsigned long ra = *cur->sp++;
4034 if (ra == 0)
4035 {
4036 cache_put (wctx, RA_EOSTCK);
4037 DprintfT (SP_DUMP_UNWIND, "unwind.c:%d returns RA_END_OF_STACK wctx->pc = 0x%lx\n", __LINE__, wctx->pc);
4038 if (save_ctx)
4039 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_END_OF_STACK);
4040 return RA_END_OF_STACK;
4041 }
4042
4043 unsigned long tbgn = wctx->tbgn;
4044 unsigned long tend = wctx->tend;
4045 if (ra < tbgn || ra >= tend)
4046 {
4047 // We do not know yet if update_map_segments is really needed
4048 if (!__collector_check_segment (ra, &tbgn, &tend, 0))
4049 {
4050 DprintfT (SP_DUMP_UNWIND, "unwind.c: __collector_check_segment fail. wctx->pc = 0x%lx\n", wctx->pc);
4051 if (do_walk == 0)
4052 {
4053 cur->sp = cur_sp;
4054 cur->fp = cur_fp;
4055 do_walk = 1;
4056 save_ctx = 1;
4057 goto startWalk;
4058 }
4059 if (save_ctx)
4060 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_FAILURE);
4061 return RA_FAILURE;
4062 }
4063 }
4064
4065 unsigned long npc = adjust_ret_addr (ra, ra - tbgn, tend);
4066 if (npc == 0)
4067 {
4068 DprintfT (SP_DUMP_UNWIND, "unwind.c: adjust_ret_addr fail. wctx->pc = 0x%lx\n", wctx->pc);
4069 if (do_walk == 0)
4070 {
4071 cur->sp = cur_sp;
4072 cur->fp = cur_fp;
4073 do_walk = 1;
4074 save_ctx = 1;
4075 goto startWalk;
4076 }
4077 if (save_ctx)
4078 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_FAILURE);
4079 return RA_FAILURE;
4080 }
4081 wctx->pc = npc;
4082 wctx->sp = (unsigned long) cur->sp;
4083 wctx->fp = fp;
4084 wctx->tbgn = tbgn;
4085 wctx->tend = tend;
4086
4087 if (save_ctx)
4088 {
4089 omp_cache_put (cur->sp_safe, &wctx_pc_save, wctx, RA_SUCCESS);
4090 DprintfT (SP_DUMP_UNWIND, "unwind.c: cache walk context. wctx_pc_save->pc = 0x%lx\n", wctx_pc_save.pc);
4091 }
4092 return RA_SUCCESS;
4093 }
4094
4095 /*
4096 * We have the return address, but we would like to report to the user
4097 * the calling PC, which is the instruction immediately preceding the
4098 * return address. Unfortunately, x86 instructions can have variable
4099 * length. So we back up 8 bytes and try to figure out where the
4100 * calling PC starts. (FWIW, call instructions are often 5-bytes long.)
4101 */
4102 unsigned long
4103 adjust_ret_addr (unsigned long ra, unsigned long segoff, unsigned long tend)
4104 {
4105 unsigned long npc = 0;
4106 int i = segoff < 8 ? segoff : 8;
4107 for (; i > 1; i--)
4108 {
4109 unsigned char *ptr = (unsigned char*) ra - i;
4110 int z = 4;
4111 int a = 4;
4112 int done = 0;
4113 int bVal;
4114 while (!done)
4115 {
4116 bVal = getByteInstruction (ptr);
4117 if (bVal < 0)
4118 return 0;
4119 switch (bVal)
4120 {
4121 case 0x26:
4122 case 0x36:
4123 #if WSIZE(64)
4124 ptr += 1;
4125 break;
4126 #endif
4127 case 0x64:
4128 case 0x65:
4129 bVal = getByteInstruction (ptr + 1);
4130 if (bVal < 0)
4131 return 0;
4132 if (bVal == 0xe8)
4133 // a workaround for bug 16193041, assuming "call Jz" has no segment override prefix
4134 done = 1;
4135 else
4136 ptr += 1;
4137 break;
4138 case 0x66:
4139 z = 2;
4140 ptr += 1;
4141 break;
4142 case 0x67:
4143 a = 2;
4144 ptr += 1;
4145 break;
4146 default:
4147 done = 1;
4148 break;
4149 }
4150 }
4151 #if WSIZE(64)
4152 bVal = getByteInstruction (ptr);
4153 if (bVal < 0)
4154 return 0;
4155 if (bVal >= 0x40 && bVal <= 0x4f)
4156 { /* XXXX not all REX codes applicable */
4157 if (bVal & 0x8)
4158 z = 4;
4159 ptr += 1;
4160 }
4161 #endif
4162 int opcode = getByteInstruction (ptr);
4163 if (opcode < 0)
4164 return 0;
4165 ptr++;
4166 switch (opcode)
4167 {
4168 case 0xe8: /* call Jz (f64) */
4169 ptr += z;
4170 break;
4171 case 0x9a: /* callf Ap */
4172 ptr += 2 + a;
4173 break;
4174 case 0xff: /* calln Ev , callf Ep */
4175 {
4176 int extop = MRM_EXT (*ptr);
4177 if (extop == 2 || extop == 3)
4178 ptr = check_modrm (ptr);
4179 }
4180 break;
4181 default:
4182 continue;
4183 }
4184 if ((unsigned long) ptr == ra)
4185 {
4186 npc = ra - i;
4187 break;
4188 }
4189 }
4190 if (npc == 0)
4191 {
4192 unsigned char * ptr = (unsigned char *) ra;
4193 #if WSIZE(32)
4194 // test __kernel_sigreturn or __kernel_rt_sigreturn
4195 if ((ra + 7 < tend && getByteInstruction (ptr) == 0x58
4196 && getByteInstruction (ptr + 1) == 0xb8
4197 && getByteInstruction (ptr + 6) == 0xcd
4198 && getByteInstruction (ptr + 7) == 0x80) /* pop %eax; mov $NNNN, %eax; int */
4199 || (ra + 7 < tend && getByteInstruction (ptr) == 0x58
4200 && getByteInstruction (ptr + 1) == 0xb8
4201 && getByteInstruction (ptr + 6) == 0x0f
4202 && getByteInstruction (ptr + 7) == 0x05) /* pop %eax; mov $NNNN, %eax; syscall */
4203 || (ra + 6 < tend && getByteInstruction (ptr) == 0xb8
4204 && getByteInstruction (ptr + 5) == 0xcd
4205 && getByteInstruction (ptr + 6) == 0x80) /* mov $NNNN, %eax; int */
4206 || (ra + 6 < tend && getByteInstruction (ptr) == 0xb8
4207 && getByteInstruction (ptr + 5) == 0x0f
4208 && getByteInstruction (ptr + 6) == 0x05)) /* mov $NNNN, %eax; syscall */
4209 #else //WSIZE(64)
4210 // test __restore_rt
4211 if (ra + 8 < tend && getByteInstruction (ptr) == 0x48
4212 && getByteInstruction (ptr + 7) == 0x0f
4213 && getByteInstruction (ptr + 8) == 0x05) /* mov $NNNNNNNN, %rax; syscall */
4214 #endif
4215 {
4216 npc = ra;
4217 }
4218 }
4219 if (npc == 0 && __collector_java_mode
4220 && __collector_java_asyncgetcalltrace_loaded)
4221 { // detect jvm interpreter code for java user threads
4222 unsigned char * ptr = (unsigned char *) ra;
4223 #if WSIZE(32)
4224 // up to J170
4225 /*
4226 * ff 24 9d e0 64 02 f5 jmp *-0xafd9b20(,%ebx,4)
4227 * 8b 4e 01 movl 1(%esi),%ecx
4228 * f7 d1 notl %ecx
4229 * 8b 5d ec movl -0x14(%ebp),%ebx
4230 * c1 e1 02 shll $2,%ecx
4231 * eb d8 jmp .-0x26 [ 0x92a ]
4232 * 83 ec 08 subl $8,%esp || 8b 65 f8 movl -8(%ebp),%esp
4233 * */
4234 if (ra - 20 >= (ra - segoff) && ((*ptr == 0x83 && *(ptr + 1) == 0xec) || (*ptr == 0x8b && *(ptr + 1) == 0x65))
4235 && *(ptr - 2) == 0xeb
4236 && *(ptr - 5) == 0xc1 && *(ptr - 4) == 0xe1
4237 && *(ptr - 8) == 0x8b && *(ptr - 7) == 0x5d
4238 && *(ptr - 10) == 0xf7 && *(ptr - 9) == 0xd1
4239 && *(ptr - 13) == 0x8b && *(ptr - 12) == 0x4e
4240 && *(ptr - 20) == 0xff && *(ptr - 19) == 0x24 && *(ptr - 18) == 0x9d)
4241 {
4242 npc = ra - 20;
4243 }
4244 // J180 J190
4245 // ff 24 9d ** ** ** ** jmp *-0x*******(,%ebx,4)
4246 if (npc == 0
4247 && ra - 7 >= (ra - segoff)
4248 && *(ptr - 7) == 0xff
4249 && *(ptr - 6) == 0x24
4250 && *(ptr - 5) == 0x9d)
4251 {
4252 npc = ra - 7;
4253 }
4254 #else //WSIZE(64)
4255 // up to J170
4256 /*
4257 * 41 ff 24 da jmp *(%r10,%rbx,8)
4258 * 41 8b 4d 01 movl 1(%r13),%ecx
4259 * f7 d1 notl %ecx
4260 * 48 8b 5d d8 movq -0x28(%rbp),%rbx
4261 * c1 e1 02 shll $2,%ecx
4262 * eb cc jmp .-0x32 [ 0xd23 ]
4263 * 48 8b 65 f0 movq -0x10(%rbp),%rsp
4264 */
4265 if (ra - 19 >= (ra - segoff) && *ptr == 0x48 && ((*(ptr + 1) == 0x8b && *(ptr + 2) == 0x65) || (*(ptr + 1) == 0x83 && *(ptr + 2) == 0xec))
4266 && *(ptr - 2) == 0xeb
4267 && *(ptr - 5) == 0xc1 && *(ptr - 4) == 0xe1
4268 && *(ptr - 9) == 0x48 && *(ptr - 8) == 0x8b && *(ptr - 7) == 0x5d
4269 && *(ptr - 11) == 0xf7 && *(ptr - 10) == 0xd1
4270 && *(ptr - 15) == 0x41 && *(ptr - 14) == 0x8b && *(ptr - 13) == 0x4d
4271 && *(ptr - 19) == 0x41 && *(ptr - 18) == 0xff)
4272 npc = ra - 19;
4273 // J180 J190
4274 // 41 ff 24 da jmp *(%r10,%rbx,8)
4275 if (npc == 0
4276 && ra - 4 >= (ra - segoff)
4277 && *(ptr - 4) == 0x41
4278 && *(ptr - 3) == 0xff
4279 && *(ptr - 2) == 0x24
4280 && *(ptr - 1) == 0xda)
4281 npc = ra - 4;
4282 #endif
4283 }
4284
4285 return npc;
4286 }
4287
4288 /*
4289 * Parses AVX instruction and returns its length.
4290 * Returns 0 if parsing failed.
4291 * https://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-instruction-set-reference-manual-325383.pdf
4292 */
4293 static int
4294 parse_x86_AVX_instruction (unsigned char *pc)
4295 {
4296 /*
4297 * VEX prefix has a two-byte form (0xc5) and a three byte form (0xc4).
4298 * If an instruction syntax can be encoded using the two-byte form,
4299 * it can also be encoded using the three byte form of VEX.
4300 * The latter increases the length of the instruction by one byte.
4301 * This may be helpful in some situations for code alignment.
4302 *
4303 Byte 0 Byte 1 Byte 2 Byte 3
4304 (Bit Position) 7 0 7 6 5 4 0 7 6 3 2 10
4305 3-byte VEX [ 11000100 ] [ R X B | m-mmmm ] [ W | vvvv | L | pp ]
4306 7 0 7 6 3 2 10
4307 2-byte VEX [ 11000101 ] [ R | vvvv | L | pp ]
4308 7 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0
4309 4-byte EVEX [ 01100010 ] [ R X B R1 0 0 m m ] [ W v v v v 1 p p ] [ z L1 L B1 V1 a a a ]
4310
4311 R: REX.R in 1's complement (inverted) form
4312 0: Same as REX.R=1 (64-bit mode only)
4313 1: Same as REX.R=0 (must be 1 in 32-bit mode)
4314
4315 X: REX.X in 1's complement (inverted) form
4316 0: Same as REX.X=1 (64-bit mode only)
4317 1: Same as REX.X=0 (must be 1 in 32-bit mode)
4318
4319 B: REX.B in 1's complement (inverted) form
4320 0: Same as REX.B=1 (64-bit mode only)
4321 1: Same as REX.B=0 (Ignored in 32-bit mode).
4322
4323 W: opcode specific (use like REX.W, or used for opcode
4324 extension, or ignored, depending on the opcode byte)
4325
4326 m-mmmm:
4327 00000: Reserved for future use (will #UD)
4328 00001: implied 0F leading opcode byte
4329 00010: implied 0F 38 leading opcode bytes
4330 00011: implied 0F 3A leading opcode bytes
4331 00100-11111: Reserved for future use (will #UD)
4332
4333 vvvv: a register specifier (in 1's complement form) or 1111 if unused.
4334
4335 L: Vector Length
4336 0: scalar or 128-bit vector
4337 1: 256-bit vector
4338
4339 pp: opcode extension providing equivalent functionality of a SIMD prefix
4340 00: None
4341 01: 66
4342 10: F3
4343 11: F2
4344 *
4345 * Example: 0xc5f877L vzeroupper
4346 * VEX prefix: 0xc5 0x77
4347 * Opcode: 0xf8
4348 *
4349 */
4350 int len = 0;
4351 disassemble_info dis_info;
4352 dis_info.arch = bfd_arch_i386;
4353 dis_info.mach = bfd_mach_x86_64;
4354 dis_info.flavour = bfd_target_unknown_flavour;
4355 dis_info.endian = BFD_ENDIAN_UNKNOWN;
4356 dis_info.endian_code = dis_info.endian;
4357 dis_info.octets_per_byte = 1;
4358 dis_info.disassembler_needs_relocs = FALSE;
4359 dis_info.fprintf_func = fprintf_func;
4360 dis_info.fprintf_styled_func = fprintf_styled_func;
4361 dis_info.stream = NULL;
4362 dis_info.disassembler_options = NULL;
4363 dis_info.read_memory_func = read_memory_func;
4364 dis_info.memory_error_func = memory_error_func;
4365 dis_info.print_address_func = print_address_func;
4366 dis_info.symbol_at_address_func = symbol_at_address_func;
4367 dis_info.symbol_is_valid = symbol_is_valid;
4368 dis_info.display_endian = BFD_ENDIAN_UNKNOWN;
4369 dis_info.symtab = NULL;
4370 dis_info.symtab_size = 0;
4371 dis_info.buffer_vma = 0;
4372 dis_info.buffer = pc;
4373 dis_info.buffer_length = 8;
4374
4375 disassembler_ftype disassemble = print_insn_i386;
4376 if (disassemble == NULL)
4377 {
4378 DprintfT (SP_DUMP_UNWIND, "parse_x86_AVX_instruction ERROR: unsupported disassemble\n");
4379 return 0;
4380 }
4381 len = disassemble (0, &dis_info);
4382 DprintfT (SP_DUMP_UNWIND, "parse_x86_AVX_instruction: returned %d pc: %p\n", len, pc);
4383 return len;
4384 }
4385
4386 /*
4387 * In the Intel world, a stack frame looks like this:
4388 *
4389 * %fp0->| |
4390 * |-------------------------------|
4391 * | Args to next subroutine |
4392 * |-------------------------------|-\
4393 * %sp0->| One word struct-ret address | |
4394 * |-------------------------------| > minimum stack frame (8 bytes)
4395 * | Previous frame pointer (%fp0)| |
4396 * %fp1->|-------------------------------|-/
4397 * | Local variables |
4398 * %sp1->|-------------------------------|
4399 *
4400 */
4401
4402 int
4403 stack_unwind (char *buf, int size, void *bptr, void *eptr, ucontext_t *context, int mode)
4404 {
4405 long *lbuf = (long*) buf;
4406 int lsize = size / sizeof (long);
4407 int ind = 0;
4408 int do_walk = 1;
4409 int extra_frame = 0;
4410 if (mode & FRINFO_NO_WALK)
4411 do_walk = 0;
4412 if ((mode & 0xffff) == FRINFO_FROM_STACK)
4413 extra_frame = 1;
4414
4415 /*
4416 * trace the stack frames from user stack.
4417 * We are assuming that the frame pointer and return address
4418 * are null when we are at the top level.
4419 */
4420 struct WalkContext wctx;
4421 wctx.pc = GET_PC (context);
4422 wctx.sp = GET_SP (context);
4423 wctx.fp = GET_FP (context);
4424 wctx.ln = (unsigned long) context->uc_link;
4425 unsigned long *sbase = (unsigned long*) __collector_tsd_get_by_key (unwind_key);
4426 if (sbase && *sbase > wctx.sp)
4427 wctx.sbase = *sbase;
4428 else
4429 {
4430 wctx.sbase = wctx.sp + 0x100000;
4431 if (wctx.sbase < wctx.sp) /* overflow */
4432 wctx.sbase = (unsigned long) - 1;
4433 }
4434 // We do not know yet if update_map_segments is really needed
4435 __collector_check_segment (wctx.pc, &wctx.tbgn, &wctx.tend, 0);
4436
4437 for (;;)
4438 {
4439 if (ind >= lsize || wctx.pc == 0)
4440 break;
4441 if (bptr != NULL && extra_frame && wctx.sp <= (unsigned long) bptr && ind < 2)
4442 {
4443 lbuf[0] = wctx.pc;
4444 if (ind == 0)
4445 {
4446 ind++;
4447 if (ind >= lsize)
4448 break;
4449 }
4450 }
4451 if (bptr == NULL || wctx.sp > (unsigned long) bptr)
4452 {
4453 lbuf[ind++] = wctx.pc;
4454 if (ind >= lsize)
4455 break;
4456 }
4457
4458 for (;;)
4459 {
4460 if (eptr != NULL && wctx.sp >= (unsigned long) eptr)
4461 {
4462 ind = ind >= 2 ? ind - 2 : 0;
4463 goto exit;
4464 }
4465 int ret = find_i386_ret_addr (&wctx, do_walk);
4466 DprintfT (SP_DUMP_UNWIND, "stack_unwind (x86 walk):%d find_i386_ret_addr returns %d\n", __LINE__, ret);
4467 if (ret == RA_FAILURE)
4468 {
4469 /* lbuf[ind++] = SP_FAILED_UNWIND_MARKER; */
4470 goto exit;
4471 }
4472
4473 if (ret == RA_END_OF_STACK)
4474 goto exit;
4475 #if WSIZE(32)
4476 if (ret == RA_RT_SIGRETURN)
4477 {
4478 struct SigFrame
4479 {
4480 unsigned long arg0;
4481 unsigned long arg1;
4482 unsigned long arg2;
4483 } *sframe = (struct SigFrame*) wctx.sp;
4484 ucontext_t *ncontext = (ucontext_t*) sframe->arg2;
4485 wctx.pc = GET_PC (ncontext);
4486 if (!__collector_check_segment (wctx.pc, &wctx.tbgn, &wctx.tend, 0))
4487 {
4488 /* lbuf[ind++] = SP_FAILED_UNWIND_MARKER; */
4489 goto exit;
4490 }
4491 unsigned long nsp = GET_SP (ncontext);
4492 /* Check the new stack pointer */
4493 if (nsp <= sframe->arg2 || nsp > sframe->arg2 + sizeof (ucontext_t) + 1024)
4494 {
4495 /* lbuf[ind++] = SP_FAILED_UNWIND_MARKER; */
4496 goto exit;
4497 }
4498 wctx.sp = nsp;
4499 wctx.fp = GET_FP (ncontext);
4500 break;
4501 }
4502 else if (ret == RA_SIGRETURN)
4503 {
4504 struct sigcontext *sctx = (struct sigcontext*) wctx.sp;
4505 wctx.pc = sctx->eip;
4506 if (!__collector_check_segment (wctx.pc, &wctx.tbgn, &wctx.tend, 0))
4507 {
4508 /* lbuf[ind++] = SP_FAILED_UNWIND_MARKER; */
4509 goto exit;
4510 }
4511 wctx.sp = sctx->esp;
4512 wctx.fp = sctx->ebp;
4513 break;
4514 }
4515 #elif WSIZE(64)
4516 if (ret == RA_RT_SIGRETURN)
4517 {
4518 ucontext_t *ncontext = (ucontext_t*) wctx.sp;
4519 wctx.pc = GET_PC (ncontext);
4520 if (!__collector_check_segment (wctx.pc, &wctx.tbgn, &wctx.tend, 0))
4521 {
4522 /* lbuf[ind++] = SP_FAILED_UNWIND_MARKER; */
4523 goto exit;
4524 }
4525 unsigned long nsp = GET_SP (ncontext);
4526 /* Check the new stack pointer */
4527 if (nsp <= wctx.sp || nsp > wctx.sp + sizeof (ucontext_t) + 1024)
4528 {
4529 /* lbuf[ind++] = SP_FAILED_UNWIND_MARKER; */
4530 goto exit;
4531 }
4532 wctx.sp = nsp;
4533 wctx.fp = GET_FP (ncontext);
4534 break;
4535 }
4536 #endif /* WSIZE() */
4537 if (bptr != NULL && extra_frame && wctx.sp <= (unsigned long) bptr && ind < 2)
4538 {
4539 lbuf[0] = wctx.pc;
4540 if (ind == 0)
4541 {
4542 ind++;
4543 if (ind >= lsize)
4544 break;
4545 }
4546 }
4547 if (bptr == NULL || wctx.sp > (unsigned long) bptr)
4548 {
4549 lbuf[ind++] = wctx.pc;
4550 if (ind >= lsize)
4551 goto exit;
4552 }
4553 }
4554 }
4555
4556 exit:
4557 #if defined(DEBUG)
4558 if ((SP_DUMP_UNWIND & __collector_tracelevel) != 0)
4559 {
4560 DprintfT (SP_DUMP_UNWIND, "stack_unwind (x86 walk):%d found %d frames\n\n", __LINE__, ind);
4561 for (int i = 0; i < ind; i++)
4562 DprintfT (SP_DUMP_UNWIND, " %3d: 0x%lx\n", i, (unsigned long) lbuf[i]);
4563 }
4564 #endif
4565 dump_stack (__LINE__);
4566 if (ind >= lsize)
4567 {
4568 ind = lsize - 1;
4569 lbuf[ind++] = (unsigned long) SP_TRUNC_STACK_MARKER;
4570 }
4571 return ind * sizeof (long);
4572 }
4573
4574 #elif ARCH(Aarch64)
4575
4576 static int
4577 stack_unwind (char *buf, int size, void *bptr, void *eptr, ucontext_t *context, int mode)
4578 {
4579 if (buf && bptr && eptr && context && size + mode > 0)
4580 getByteInstruction ((unsigned char *) eptr);
4581 int ind = 0;
4582 __u64 *lbuf = (void *) buf;
4583 int lsize = size / sizeof (__u64);
4584 __u64 pc = context->uc_mcontext.pc;
4585 __u64 sp = context->uc_mcontext.sp;
4586 __u64 stack_base;
4587 unsigned long tbgn = 0;
4588 unsigned long tend = 0;
4589
4590 unsigned long *sbase = (unsigned long*) __collector_tsd_get_by_key (unwind_key);
4591 if (sbase && *sbase > sp)
4592 stack_base = *sbase;
4593 else
4594 {
4595 stack_base = sp + 0x100000;
4596 if (stack_base < sp) // overflow
4597 stack_base = (__u64) -1;
4598 }
4599 DprintfT (SP_DUMP_UNWIND,
4600 "unwind.c:%d stack_unwind %2d pc=0x%llx sp=0x%llx stack_base=0x%llx\n",
4601 __LINE__, ind, (unsigned long long) pc, (unsigned long long) sp,
4602 (unsigned long long) stack_base);
4603
4604 while (sp && pc)
4605 {
4606 DprintfT (SP_DUMP_UNWIND,
4607 "unwind.c:%d stack_unwind %2d pc=0x%llx sp=0x%llx\n",
4608 __LINE__, ind, (unsigned long long) pc, (unsigned long long) sp);
4609 // Dl_info dlinfo;
4610 // if (!dladdr ((void *) pc, &dlinfo))
4611 // break;
4612 // DprintfT (SP_DUMP_UNWIND, "%2d: %llx <%s+%llu> (%s)\n",
4613 // ind, (unsigned long long) pc,
4614 // dlinfo.dli_sname ? dlinfo.dli_sname : "(?)",
4615 // (unsigned long long) pc - (unsigned long long) dlinfo.dli_saddr,
4616 // dlinfo.dli_fname);
4617 lbuf[ind++] = pc;
4618 if (ind >= lsize || sp >= stack_base || (sp & 15) != 0)
4619 break;
4620 if (pc < tbgn || pc >= tend)
4621 if (!__collector_check_segment ((unsigned long) pc, &tbgn, &tend, 0))
4622 {
4623 DprintfT (SP_DUMP_UNWIND,
4624 "unwind.c:%d __collector_check_segment failed. sp=0x%lx\n",
4625 __LINE__, (unsigned long) sp);
4626 break;
4627 }
4628 pc = ((__u64 *) sp)[1];
4629 __u64 old_sp = sp;
4630 sp = ((__u64 *) sp)[0];
4631 if (sp < old_sp)
4632 break;
4633 }
4634 if (ind >= lsize)
4635 {
4636 ind = lsize - 1;
4637 lbuf[ind++] = (__u64) SP_TRUNC_STACK_MARKER;
4638 }
4639 return ind * sizeof (__u64);
4640 }
4641 #endif /* ARCH() */