2 * Copyright (C) 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
3 * Copyright (C) 2002-2006 Novell, Inc.
4 * Jan Beulich <jbeulich@novell.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * A simple API for unwinding kernel stacks. This is used for
11 * debugging and error reporting purposes. The kernel doesn't need
12 * full-blown stack unwinding with all the bells and whistles, so there
13 * is not much point in implementing the full Dwarf2 unwind API.
16 #include <linux/sched.h>
17 #include <linux/module.h>
18 #include <linux/bootmem.h>
19 #include <linux/sort.h>
20 #include <linux/slab.h>
21 #include <linux/stop_machine.h>
22 #include <linux/uaccess.h>
23 #include <linux/ptrace.h>
24 #include <asm/sections.h>
25 #include <asm/unaligned.h>
26 #include <asm/unwind.h>
28 extern char __start_unwind[], __end_unwind[];
29 /* extern const u8 __start_unwind_hdr[], __end_unwind_hdr[];*/
31 /* #define UNWIND_DEBUG */
35 #define unw_debug(fmt, ...) \
38 pr_info(fmt, ##__VA_ARGS__); \
41 #define unw_debug(fmt, ...)
44 #define MAX_STACK_DEPTH 8
46 #define EXTRA_INFO(f) { \
47 BUILD_BUG_ON_ZERO(offsetof(struct unwind_frame_info, f) \
48 % FIELD_SIZEOF(struct unwind_frame_info, f)) \
49 + offsetof(struct unwind_frame_info, f) \
50 / FIELD_SIZEOF(struct unwind_frame_info, f), \
51 FIELD_SIZEOF(struct unwind_frame_info, f) \
53 #define PTREGS_INFO(f) EXTRA_INFO(regs.f)
56 unsigned offs:BITS_PER_LONG / 2;
57 unsigned width:BITS_PER_LONG / 2;
65 #define REG_INVALID(r) (reg_info[r].width == 0)
68 #define DW_CFA_nop 0x00
69 #define DW_CFA_set_loc 0x01
70 #define DW_CFA_advance_loc1 0x02
71 #define DW_CFA_advance_loc2 0x03
72 #define DW_CFA_advance_loc4 0x04
73 #define DW_CFA_offset_extended 0x05
74 #define DW_CFA_restore_extended 0x06
75 #define DW_CFA_undefined 0x07
76 #define DW_CFA_same_value 0x08
77 #define DW_CFA_register 0x09
78 #define DW_CFA_remember_state 0x0a
79 #define DW_CFA_restore_state 0x0b
80 #define DW_CFA_def_cfa 0x0c
81 #define DW_CFA_def_cfa_register 0x0d
82 #define DW_CFA_def_cfa_offset 0x0e
83 #define DW_CFA_def_cfa_expression 0x0f
84 #define DW_CFA_expression 0x10
85 #define DW_CFA_offset_extended_sf 0x11
86 #define DW_CFA_def_cfa_sf 0x12
87 #define DW_CFA_def_cfa_offset_sf 0x13
88 #define DW_CFA_val_offset 0x14
89 #define DW_CFA_val_offset_sf 0x15
90 #define DW_CFA_val_expression 0x16
91 #define DW_CFA_lo_user 0x1c
92 #define DW_CFA_GNU_window_save 0x2d
93 #define DW_CFA_GNU_args_size 0x2e
94 #define DW_CFA_GNU_negative_offset_extended 0x2f
95 #define DW_CFA_hi_user 0x3f
97 #define DW_EH_PE_FORM 0x07
98 #define DW_EH_PE_native 0x00
99 #define DW_EH_PE_leb128 0x01
100 #define DW_EH_PE_data2 0x02
101 #define DW_EH_PE_data4 0x03
102 #define DW_EH_PE_data8 0x04
103 #define DW_EH_PE_signed 0x08
104 #define DW_EH_PE_ADJUST 0x70
105 #define DW_EH_PE_abs 0x00
106 #define DW_EH_PE_pcrel 0x10
107 #define DW_EH_PE_textrel 0x20
108 #define DW_EH_PE_datarel 0x30
109 #define DW_EH_PE_funcrel 0x40
110 #define DW_EH_PE_aligned 0x50
111 #define DW_EH_PE_indirect 0x80
112 #define DW_EH_PE_omit 0xff
114 typedef unsigned long uleb128_t;
115 typedef signed long sleb128_t;
117 static struct unwind_table {
124 const unsigned char *header;
126 struct unwind_table *link;
140 struct unwind_state {
142 const u8 *cieStart, *cieEnd;
148 struct unwind_item regs[ARRAY_SIZE(reg_info)];
149 unsigned stackDepth:8;
152 const u8 *stack[MAX_STACK_DEPTH];
155 static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 };
157 static struct unwind_table *find_table(unsigned long pc)
159 struct unwind_table *table;
161 for (table = &root_table; table; table = table->link)
162 if ((pc >= table->core.pc
163 && pc < table->core.pc + table->core.range)
164 || (pc >= table->init.pc
165 && pc < table->init.pc + table->init.range))
171 static unsigned long read_pointer(const u8 **pLoc,
172 const void *end, signed ptrType);
173 static void init_unwind_hdr(struct unwind_table *table,
174 void *(*alloc) (unsigned long));
177 * wrappers for header alloc (vs. calling one vs. other at call site)
178 * to elide section mismatches warnings
180 static void *__init unw_hdr_alloc_early(unsigned long sz)
182 return __alloc_bootmem_nopanic(sz, sizeof(unsigned int),
186 static void *unw_hdr_alloc(unsigned long sz)
188 return kmalloc(sz, GFP_KERNEL);
191 static void init_unwind_table(struct unwind_table *table, const char *name,
192 const void *core_start, unsigned long core_size,
193 const void *init_start, unsigned long init_size,
194 const void *table_start, unsigned long table_size,
195 const u8 *header_start, unsigned long header_size)
197 const u8 *ptr = header_start + 4;
198 const u8 *end = header_start + header_size;
200 table->core.pc = (unsigned long)core_start;
201 table->core.range = core_size;
202 table->init.pc = (unsigned long)init_start;
203 table->init.range = init_size;
204 table->address = table_start;
205 table->size = table_size;
207 /* See if the linker provided table looks valid. */
209 || header_start[0] != 1
210 || (void *)read_pointer(&ptr, end, header_start[1]) != table_start
211 || header_start[2] == DW_EH_PE_omit
212 || read_pointer(&ptr, end, header_start[2]) <= 0
213 || header_start[3] == DW_EH_PE_omit)
216 table->hdrsz = header_size;
218 table->header = header_start;
223 void __init arc_unwind_init(void)
225 init_unwind_table(&root_table, "kernel", _text, _end - _text, NULL, 0,
226 __start_unwind, __end_unwind - __start_unwind,
228 /*__start_unwind_hdr, __end_unwind_hdr - __start_unwind_hdr);*/
230 init_unwind_hdr(&root_table, unw_hdr_alloc_early);
233 static const u32 bad_cie, not_fde;
234 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *);
235 static signed fde_pointer_type(const u32 *cie);
237 struct eh_frame_hdr_table_entry {
238 unsigned long start, fde;
241 static int cmp_eh_frame_hdr_table_entries(const void *p1, const void *p2)
243 const struct eh_frame_hdr_table_entry *e1 = p1;
244 const struct eh_frame_hdr_table_entry *e2 = p2;
246 return (e1->start > e2->start) - (e1->start < e2->start);
249 static void swap_eh_frame_hdr_table_entries(void *p1, void *p2, int size)
251 struct eh_frame_hdr_table_entry *e1 = p1;
252 struct eh_frame_hdr_table_entry *e2 = p2;
256 e1->start = e2->start;
263 static void init_unwind_hdr(struct unwind_table *table,
264 void *(*alloc) (unsigned long))
267 unsigned long tableSize = table->size, hdrSize;
275 unsigned long eh_frame_ptr;
276 unsigned int fde_count;
277 struct eh_frame_hdr_table_entry table[];
278 } __attribute__ ((__packed__)) *header;
284 pr_warn(".eh_frame_hdr for '%s' present but unusable\n",
287 if (tableSize & (sizeof(*fde) - 1))
290 for (fde = table->address, n = 0;
291 tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde;
292 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
293 const u32 *cie = cie_for_fde(fde, table);
296 if (cie == ¬_fde) /* only process FDE here */
298 if (cie == NULL || cie == &bad_cie)
299 continue; /* say FDE->CIE.version != 1 */
300 ptrType = fde_pointer_type(cie);
304 ptr = (const u8 *)(fde + 2);
305 if (!read_pointer(&ptr, (const u8 *)(fde + 1) + *fde,
307 /* FIXME_Rajesh We have 4 instances of null addresses
308 * instead of the initial loc addr
311 WARN(1, "unwinder: FDE->initial_location NULL %p\n",
312 (const u8 *)(fde + 1) + *fde);
320 hdrSize = 4 + sizeof(unsigned long) + sizeof(unsigned int)
321 + 2 * n * sizeof(unsigned long);
323 header = alloc(hdrSize);
328 header->eh_frame_ptr_enc = DW_EH_PE_abs | DW_EH_PE_native;
329 header->fde_count_enc = DW_EH_PE_abs | DW_EH_PE_data4;
330 header->table_enc = DW_EH_PE_abs | DW_EH_PE_native;
331 put_unaligned((unsigned long)table->address, &header->eh_frame_ptr);
332 BUILD_BUG_ON(offsetof(typeof(*header), fde_count)
333 % __alignof(typeof(header->fde_count)));
334 header->fde_count = n;
336 BUILD_BUG_ON(offsetof(typeof(*header), table)
337 % __alignof(typeof(*header->table)));
338 for (fde = table->address, tableSize = table->size, n = 0;
340 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
341 /* const u32 *cie = fde + 1 - fde[1] / sizeof(*fde); */
342 const u32 *cie = (const u32 *)(fde[1]);
344 if (fde[1] == 0xffffffff)
345 continue; /* this is a CIE */
347 if (*(u8 *)(cie + 2) != 1)
348 continue; /* FDE->CIE.version not supported */
350 ptr = (const u8 *)(fde + 2);
351 header->table[n].start = read_pointer(&ptr,
352 (const u8 *)(fde + 1) +
354 fde_pointer_type(cie));
355 header->table[n].fde = (unsigned long)fde;
358 WARN_ON(n != header->fde_count);
362 sizeof(*header->table),
363 cmp_eh_frame_hdr_table_entries, swap_eh_frame_hdr_table_entries);
365 table->hdrsz = hdrSize;
367 table->header = (const void *)header;
370 #ifdef CONFIG_MODULES
372 static struct unwind_table *last_table;
374 /* Must be called with module_mutex held. */
375 void *unwind_add_table(struct module *module, const void *table_start,
376 unsigned long table_size)
378 struct unwind_table *table;
383 table = kmalloc(sizeof(*table), GFP_KERNEL);
387 init_unwind_table(table, module->name,
388 module->module_core, module->core_size,
389 module->module_init, module->init_size,
390 table_start, table_size,
393 init_unwind_hdr(table, unw_hdr_alloc);
396 unw_debug("Table added for [%s] %lx %lx\n",
397 module->name, table->core.pc, table->core.range);
400 last_table->link = table;
402 root_table.link = table;
408 struct unlink_table_info {
409 struct unwind_table *table;
413 static int unlink_table(void *arg)
415 struct unlink_table_info *info = arg;
416 struct unwind_table *table = info->table, *prev;
418 for (prev = &root_table; prev->link && prev->link != table;
423 if (info->init_only) {
425 table->init.range = 0;
428 prev->link = table->link;
438 /* Must be called with module_mutex held. */
439 void unwind_remove_table(void *handle, int init_only)
441 struct unwind_table *table = handle;
442 struct unlink_table_info info;
444 if (!table || table == &root_table)
447 if (init_only && table == last_table) {
449 table->init.range = 0;
454 info.init_only = init_only;
456 unlink_table(&info); /* XXX: SMP */
457 kfree(table->header);
461 #endif /* CONFIG_MODULES */
463 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end)
465 const u8 *cur = *pcur;
469 for (shift = 0, value = 0; cur < end; shift += 7) {
470 if (shift + 7 > 8 * sizeof(value)
471 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
475 value |= (uleb128_t) (*cur & 0x7f) << shift;
476 if (!(*cur++ & 0x80))
484 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end)
486 const u8 *cur = *pcur;
490 for (shift = 0, value = 0; cur < end; shift += 7) {
491 if (shift + 7 > 8 * sizeof(value)
492 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
496 value |= (sleb128_t) (*cur & 0x7f) << shift;
497 if (!(*cur & 0x80)) {
498 value |= -(*cur++ & 0x40) << shift;
507 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *table)
511 if (!*fde || (*fde & (sizeof(*fde) - 1)))
514 if (fde[1] == 0xffffffff)
515 return ¬_fde; /* this is a CIE */
517 if ((fde[1] & (sizeof(*fde) - 1)))
518 /* || fde[1] > (unsigned long)(fde + 1) - (unsigned long)table->address) */
519 return NULL; /* this is not a valid FDE */
521 /* cie = fde + 1 - fde[1] / sizeof(*fde); */
522 cie = (u32 *) fde[1];
524 if (*cie <= sizeof(*cie) + 4 || *cie >= fde[1] - sizeof(*fde)
525 || (*cie & (sizeof(*cie) - 1))
526 || (cie[1] != 0xffffffff)
527 || ( *(u8 *)(cie + 2) != 1)) /* version 1 supported */
528 return NULL; /* this is not a (valid) CIE */
532 static unsigned long read_pointer(const u8 **pLoc, const void *end,
535 unsigned long value = 0;
542 const unsigned long *pul;
545 if (ptrType < 0 || ptrType == DW_EH_PE_omit)
548 switch (ptrType & DW_EH_PE_FORM) {
550 if (end < (const void *)(ptr.p16u + 1))
552 if (ptrType & DW_EH_PE_signed)
553 value = get_unaligned((u16 *) ptr.p16s++);
555 value = get_unaligned((u16 *) ptr.p16u++);
559 if (end < (const void *)(ptr.p32u + 1))
561 if (ptrType & DW_EH_PE_signed)
562 value = get_unaligned(ptr.p32s++);
564 value = get_unaligned(ptr.p32u++);
567 BUILD_BUG_ON(sizeof(u64) != sizeof(value));
569 BUILD_BUG_ON(sizeof(u32) != sizeof(value));
571 case DW_EH_PE_native:
572 if (end < (const void *)(ptr.pul + 1))
574 value = get_unaligned((unsigned long *)ptr.pul++);
576 case DW_EH_PE_leb128:
577 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value));
578 value = ptrType & DW_EH_PE_signed ? get_sleb128(&ptr.p8, end)
579 : get_uleb128(&ptr.p8, end);
580 if ((const void *)ptr.p8 > end)
586 switch (ptrType & DW_EH_PE_ADJUST) {
590 value += (unsigned long)*pLoc;
595 if ((ptrType & DW_EH_PE_indirect)
596 && __get_user(value, (unsigned long __user *)value))
603 static signed fde_pointer_type(const u32 *cie)
605 const u8 *ptr = (const u8 *)(cie + 2);
606 unsigned version = *ptr;
609 return -1; /* unsupported */
613 const u8 *end = (const u8 *)(cie + 1) + *cie;
616 /* check if augmentation size is first (and thus present) */
620 /* check if augmentation string is nul-terminated */
621 aug = (const void *)ptr;
622 ptr = memchr(aug, 0, end - ptr);
626 ++ptr; /* skip terminator */
627 get_uleb128(&ptr, end); /* skip code alignment */
628 get_sleb128(&ptr, end); /* skip data alignment */
629 /* skip return address column */
630 version <= 1 ? (void) ++ptr : (void)get_uleb128(&ptr, end);
631 len = get_uleb128(&ptr, end); /* augmentation length */
633 if (ptr + len < ptr || ptr + len > end)
645 signed ptrType = *ptr++;
647 if (!read_pointer(&ptr, end, ptrType)
659 return DW_EH_PE_native | DW_EH_PE_abs;
662 static int advance_loc(unsigned long delta, struct unwind_state *state)
664 state->loc += delta * state->codeAlign;
666 /* FIXME_Rajesh: Probably we are defining for the initial range as well;
669 unw_debug("delta %3lu => loc 0x%lx: ", delta, state->loc);
673 static void set_rule(uleb128_t reg, enum item_location where, uleb128_t value,
674 struct unwind_state *state)
676 if (reg < ARRAY_SIZE(state->regs)) {
677 state->regs[reg].where = where;
678 state->regs[reg].value = value;
681 unw_debug("r%lu: ", reg);
687 unw_debug("c(%lu) ", value);
690 unw_debug("r(%lu) ", value);
693 unw_debug("v(%lu) ", value);
702 static int processCFI(const u8 *start, const u8 *end, unsigned long targetLoc,
703 signed ptrType, struct unwind_state *state)
713 if (start != state->cieStart) {
714 state->loc = state->org;
716 processCFI(state->cieStart, state->cieEnd, 0, ptrType,
718 if (targetLoc == 0 && state->label == NULL)
721 for (ptr.p8 = start; result && ptr.p8 < end;) {
722 switch (*ptr.p8 >> 6) {
730 unw_debug("cfa nop ");
733 state->loc = read_pointer(&ptr.p8, end,
737 unw_debug("cfa_set_loc: 0x%lx ", state->loc);
739 case DW_CFA_advance_loc1:
740 unw_debug("\ncfa advance loc1:");
741 result = ptr.p8 < end
742 && advance_loc(*ptr.p8++, state);
744 case DW_CFA_advance_loc2:
746 value += *ptr.p8++ << 8;
747 unw_debug("\ncfa advance loc2:");
748 result = ptr.p8 <= end + 2
749 /* && advance_loc(*ptr.p16++, state); */
750 && advance_loc(value, state);
752 case DW_CFA_advance_loc4:
753 unw_debug("\ncfa advance loc4:");
754 result = ptr.p8 <= end + 4
755 && advance_loc(*ptr.p32++, state);
757 case DW_CFA_offset_extended:
758 value = get_uleb128(&ptr.p8, end);
759 unw_debug("cfa_offset_extended: ");
760 set_rule(value, Memory,
761 get_uleb128(&ptr.p8, end), state);
763 case DW_CFA_val_offset:
764 value = get_uleb128(&ptr.p8, end);
765 set_rule(value, Value,
766 get_uleb128(&ptr.p8, end), state);
768 case DW_CFA_offset_extended_sf:
769 value = get_uleb128(&ptr.p8, end);
770 set_rule(value, Memory,
771 get_sleb128(&ptr.p8, end), state);
773 case DW_CFA_val_offset_sf:
774 value = get_uleb128(&ptr.p8, end);
775 set_rule(value, Value,
776 get_sleb128(&ptr.p8, end), state);
778 case DW_CFA_restore_extended:
779 unw_debug("cfa_restore_extended: ");
780 case DW_CFA_undefined:
781 unw_debug("cfa_undefined: ");
782 case DW_CFA_same_value:
783 unw_debug("cfa_same_value: ");
784 set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0,
787 case DW_CFA_register:
788 unw_debug("cfa_register: ");
789 value = get_uleb128(&ptr.p8, end);
792 get_uleb128(&ptr.p8, end), state);
794 case DW_CFA_remember_state:
795 unw_debug("cfa_remember_state: ");
796 if (ptr.p8 == state->label) {
800 if (state->stackDepth >= MAX_STACK_DEPTH)
802 state->stack[state->stackDepth++] = ptr.p8;
804 case DW_CFA_restore_state:
805 unw_debug("cfa_restore_state: ");
806 if (state->stackDepth) {
807 const uleb128_t loc = state->loc;
808 const u8 *label = state->label;
811 state->stack[state->stackDepth - 1];
812 memcpy(&state->cfa, &badCFA,
814 memset(state->regs, 0,
815 sizeof(state->regs));
816 state->stackDepth = 0;
818 processCFI(start, end, 0, ptrType,
821 state->label = label;
826 state->cfa.reg = get_uleb128(&ptr.p8, end);
827 unw_debug("cfa_def_cfa: r%lu ", state->cfa.reg);
829 case DW_CFA_def_cfa_offset:
830 state->cfa.offs = get_uleb128(&ptr.p8, end);
831 unw_debug("cfa_def_cfa_offset: 0x%lx ",
834 case DW_CFA_def_cfa_sf:
835 state->cfa.reg = get_uleb128(&ptr.p8, end);
837 case DW_CFA_def_cfa_offset_sf:
838 state->cfa.offs = get_sleb128(&ptr.p8, end)
841 case DW_CFA_def_cfa_register:
842 unw_debug("cfa_def_cfa_regsiter: ");
843 state->cfa.reg = get_uleb128(&ptr.p8, end);
845 /*todo case DW_CFA_def_cfa_expression: */
846 /*todo case DW_CFA_expression: */
847 /*todo case DW_CFA_val_expression: */
848 case DW_CFA_GNU_args_size:
849 get_uleb128(&ptr.p8, end);
851 case DW_CFA_GNU_negative_offset_extended:
852 value = get_uleb128(&ptr.p8, end);
855 (uleb128_t) 0 - get_uleb128(&ptr.p8,
859 case DW_CFA_GNU_window_save:
861 unw_debug("UNKNOWN OPCODE 0x%x\n", opcode);
867 unw_debug("\ncfa_adv_loc: ");
868 result = advance_loc(*ptr.p8++ & 0x3f, state);
871 unw_debug("cfa_offset: ");
872 value = *ptr.p8++ & 0x3f;
873 set_rule(value, Memory, get_uleb128(&ptr.p8, end),
877 unw_debug("cfa_restore: ");
878 set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state);
884 if (result && targetLoc != 0 && targetLoc < state->loc)
888 return result && ptr.p8 == end && (targetLoc == 0 || (
889 /*todo While in theory this should apply, gcc in practice omits
890 everything past the function prolog, and hence the location
891 never reaches the end of the function.
892 targetLoc < state->loc && */ state->label == NULL));
895 /* Unwind to previous to frame. Returns 0 if successful, negative
896 * number in case of an error. */
897 int arc_unwind(struct unwind_frame_info *frame)
899 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
900 const u32 *fde = NULL, *cie = NULL;
901 const u8 *ptr = NULL, *end = NULL;
902 unsigned long pc = UNW_PC(frame) - frame->call_frame;
903 unsigned long startLoc = 0, endLoc = 0, cfa;
906 uleb128_t retAddrReg = 0;
907 const struct unwind_table *table;
908 struct unwind_state state;
912 unw_debug("\n\nUNWIND FRAME:\n");
913 unw_debug("PC: 0x%lx BLINK: 0x%lx, SP: 0x%lx, FP: 0x%x\n",
914 UNW_PC(frame), UNW_BLINK(frame), UNW_SP(frame),
917 if (UNW_PC(frame) == 0)
922 unsigned long *sptr = (unsigned long *)UNW_SP(frame);
923 unw_debug("\nStack Dump:\n");
924 for (i = 0; i < 20; i++, sptr++)
925 unw_debug("0x%p: 0x%lx\n", sptr, *sptr);
930 table = find_table(pc);
932 && !(table->size & (sizeof(*fde) - 1))) {
933 const u8 *hdr = table->header;
934 unsigned long tableSize;
937 if (hdr && hdr[0] == 1) {
938 switch (hdr[3] & DW_EH_PE_FORM) {
939 case DW_EH_PE_native:
940 tableSize = sizeof(unsigned long);
956 end = hdr + table->hdrsz;
957 if (tableSize && read_pointer(&ptr, end, hdr[1])
958 == (unsigned long)table->address
959 && (i = read_pointer(&ptr, end, hdr[2])) > 0
960 && i == (end - ptr) / (2 * tableSize)
961 && !((end - ptr) % (2 * tableSize))) {
964 ptr + (i / 2) * (2 * tableSize);
966 startLoc = read_pointer(&cur,
972 ptr = cur - tableSize;
975 } while (startLoc && i > 1);
977 && (startLoc = read_pointer(&ptr,
981 fde = (void *)read_pointer(&ptr,
989 cie = cie_for_fde(fde, table);
990 ptr = (const u8 *)(fde + 2);
994 && (ptrType = fde_pointer_type(cie)) >= 0
995 && read_pointer(&ptr,
996 (const u8 *)(fde + 1) + *fde,
997 ptrType) == startLoc) {
998 if (!(ptrType & DW_EH_PE_indirect))
1000 DW_EH_PE_FORM | DW_EH_PE_signed;
1002 startLoc + read_pointer(&ptr,
1017 memset(&state, 0, sizeof(state));
1018 state.cieEnd = ptr; /* keep here temporarily */
1019 ptr = (const u8 *)(cie + 2);
1020 end = (const u8 *)(cie + 1) + *cie;
1021 frame->call_frame = 1;
1022 if ((state.version = *ptr) != 1)
1023 cie = NULL; /* unsupported version */
1025 /* check if augmentation size is first (thus present) */
1027 while (++ptr < end && *ptr) {
1029 /* chk for ignorable or already handled
1030 * nul-terminated augmentation string */
1036 frame->call_frame = 0;
1044 if (ptr >= end || *ptr)
1050 /* get code aligment factor */
1051 state.codeAlign = get_uleb128(&ptr, end);
1052 /* get data aligment factor */
1053 state.dataAlign = get_sleb128(&ptr, end);
1054 if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end)
1058 state.version <= 1 ? *ptr++ : get_uleb128(&ptr,
1060 unw_debug("CIE Frame Info:\n");
1061 unw_debug("return Address register 0x%lx\n",
1063 unw_debug("data Align: %ld\n", state.dataAlign);
1064 unw_debug("code Align: %lu\n", state.codeAlign);
1065 /* skip augmentation */
1066 if (((const char *)(cie + 2))[1] == 'z') {
1067 uleb128_t augSize = get_uleb128(&ptr, end);
1071 if (ptr > end || retAddrReg >= ARRAY_SIZE(reg_info)
1072 || REG_INVALID(retAddrReg)
1073 || reg_info[retAddrReg].width !=
1074 sizeof(unsigned long))
1079 state.cieStart = ptr;
1082 end = (const u8 *)(fde + 1) + *fde;
1083 /* skip augmentation */
1084 if (((const char *)(cie + 2))[1] == 'z') {
1085 uleb128_t augSize = get_uleb128(&ptr, end);
1087 if ((ptr += augSize) > end)
1091 if (cie == NULL || fde == NULL) {
1092 #ifdef CONFIG_FRAME_POINTER
1093 unsigned long top, bottom;
1095 top = STACK_TOP_UNW(frame->task);
1096 bottom = STACK_BOTTOM_UNW(frame->task);
1097 #if FRAME_RETADDR_OFFSET < 0
1098 if (UNW_SP(frame) < top && UNW_FP(frame) <= UNW_SP(frame)
1099 && bottom < UNW_FP(frame)
1101 if (UNW_SP(frame) > top && UNW_FP(frame) >= UNW_SP(frame)
1102 && bottom > UNW_FP(frame)
1104 && !((UNW_SP(frame) | UNW_FP(frame))
1105 & (sizeof(unsigned long) - 1))) {
1108 if (!__get_user(link, (unsigned long *)
1109 (UNW_FP(frame) + FRAME_LINK_OFFSET))
1110 #if FRAME_RETADDR_OFFSET < 0
1111 && link > bottom && link < UNW_FP(frame)
1113 && link > UNW_FP(frame) && link < bottom
1115 && !(link & (sizeof(link) - 1))
1116 && !__get_user(UNW_PC(frame),
1117 (unsigned long *)(UNW_FP(frame)
1118 + FRAME_RETADDR_OFFSET)))
1121 UNW_FP(frame) + FRAME_RETADDR_OFFSET
1122 #if FRAME_RETADDR_OFFSET < 0
1127 sizeof(UNW_PC(frame));
1128 UNW_FP(frame) = link;
1135 state.org = startLoc;
1136 memcpy(&state.cfa, &badCFA, sizeof(state.cfa));
1138 unw_debug("\nProcess instructions\n");
1140 /* process instructions
1141 * For ARC, we optimize by having blink(retAddrReg) with
1142 * the sameValue in the leaf function, so we should not check
1143 * state.regs[retAddrReg].where == Nowhere
1145 if (!processCFI(ptr, end, pc, ptrType, &state)
1146 || state.loc > endLoc
1147 /* || state.regs[retAddrReg].where == Nowhere */
1148 || state.cfa.reg >= ARRAY_SIZE(reg_info)
1149 || reg_info[state.cfa.reg].width != sizeof(unsigned long)
1150 || state.cfa.offs % sizeof(unsigned long))
1156 unw_debug("\nRegister State Based on the rules parsed from FDE:\n");
1157 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1162 switch (state.regs[i].where) {
1166 unw_debug(" r%d: c(%lu),", i, state.regs[i].value);
1169 unw_debug(" r%d: r(%lu),", i, state.regs[i].value);
1172 unw_debug(" r%d: v(%lu),", i, state.regs[i].value);
1181 #ifndef CONFIG_AS_CFI_SIGNAL_FRAME
1182 if (frame->call_frame
1183 && !UNW_DEFAULT_RA(state.regs[retAddrReg], state.dataAlign))
1184 frame->call_frame = 0;
1186 cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs;
1187 startLoc = min_t(unsigned long, UNW_SP(frame), cfa);
1188 endLoc = max_t(unsigned long, UNW_SP(frame), cfa);
1189 if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
1190 startLoc = min(STACK_LIMIT(cfa), cfa);
1191 endLoc = max(STACK_LIMIT(cfa), cfa);
1194 unw_debug("\nCFA reg: 0x%lx, offset: 0x%lx => 0x%lx\n",
1195 state.cfa.reg, state.cfa.offs, cfa);
1197 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1198 if (REG_INVALID(i)) {
1199 if (state.regs[i].where == Nowhere)
1203 switch (state.regs[i].where) {
1207 if (state.regs[i].value >= ARRAY_SIZE(reg_info)
1208 || REG_INVALID(state.regs[i].value)
1209 || reg_info[i].width >
1210 reg_info[state.regs[i].value].width)
1212 switch (reg_info[state.regs[i].value].width) {
1214 state.regs[i].value =
1215 FRAME_REG(state.regs[i].value, const u8);
1218 state.regs[i].value =
1219 FRAME_REG(state.regs[i].value, const u16);
1222 state.regs[i].value =
1223 FRAME_REG(state.regs[i].value, const u32);
1227 state.regs[i].value =
1228 FRAME_REG(state.regs[i].value, const u64);
1238 unw_debug("\nRegister state after evaluation with realtime Stack:\n");
1239 fptr = (unsigned long *)(&frame->regs);
1240 for (i = 0; i < ARRAY_SIZE(state.regs); ++i, fptr++) {
1244 switch (state.regs[i].where) {
1246 if (reg_info[i].width != sizeof(UNW_SP(frame))
1247 || &FRAME_REG(i, __typeof__(UNW_SP(frame)))
1250 UNW_SP(frame) = cfa;
1253 switch (reg_info[i].width) {
1255 FRAME_REG(i, u8) = state.regs[i].value;
1258 FRAME_REG(i, u16) = state.regs[i].value;
1261 FRAME_REG(i, u32) = state.regs[i].value;
1265 FRAME_REG(i, u64) = state.regs[i].value;
1273 if (reg_info[i].width != sizeof(unsigned long))
1275 FRAME_REG(i, unsigned long) = cfa + state.regs[i].value
1279 addr = cfa + state.regs[i].value * state.dataAlign;
1281 if ((state.regs[i].value * state.dataAlign)
1282 % sizeof(unsigned long)
1284 || addr + sizeof(unsigned long) < addr
1285 || addr + sizeof(unsigned long) > endLoc)
1288 switch (reg_info[i].width) {
1290 __get_user(FRAME_REG(i, u8),
1294 __get_user(FRAME_REG(i, u16),
1295 (u16 __user *)addr);
1298 __get_user(FRAME_REG(i, u32),
1299 (u32 __user *)addr);
1303 __get_user(FRAME_REG(i, u64),
1304 (u64 __user *)addr);
1313 unw_debug("r%d: 0x%lx ", i, *fptr);
1319 EXPORT_SYMBOL(arc_unwind);