1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (C) 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
4 * Copyright (C) 2002-2006 Novell, Inc.
5 * Jan Beulich <jbeulich@novell.com>
7 * A simple API for unwinding kernel stacks. This is used for
8 * debugging and error reporting purposes. The kernel doesn't need
9 * full-blown stack unwinding with all the bells and whistles, so there
10 * is not much point in implementing the full Dwarf2 unwind API.
13 #include <linux/sched.h>
14 #include <linux/module.h>
15 #include <linux/memblock.h>
16 #include <linux/sort.h>
17 #include <linux/slab.h>
18 #include <linux/stop_machine.h>
19 #include <linux/uaccess.h>
20 #include <linux/ptrace.h>
21 #include <asm/sections.h>
22 #include <asm/unaligned.h>
23 #include <asm/unwind.h>
25 extern char __start_unwind[], __end_unwind[];
26 /* extern const u8 __start_unwind_hdr[], __end_unwind_hdr[];*/
28 /* #define UNWIND_DEBUG */
32 #define unw_debug(fmt, ...) \
35 pr_info(fmt, ##__VA_ARGS__); \
38 #define unw_debug(fmt, ...)
41 #define MAX_STACK_DEPTH 8
43 #define EXTRA_INFO(f) { \
44 BUILD_BUG_ON_ZERO(offsetof(struct unwind_frame_info, f) \
45 % sizeof_field(struct unwind_frame_info, f)) \
46 + offsetof(struct unwind_frame_info, f) \
47 / sizeof_field(struct unwind_frame_info, f), \
48 sizeof_field(struct unwind_frame_info, f) \
50 #define PTREGS_INFO(f) EXTRA_INFO(regs.f)
53 unsigned offs:BITS_PER_LONG / 2;
54 unsigned width:BITS_PER_LONG / 2;
62 #define REG_INVALID(r) (reg_info[r].width == 0)
65 #define DW_CFA_nop 0x00
66 #define DW_CFA_set_loc 0x01
67 #define DW_CFA_advance_loc1 0x02
68 #define DW_CFA_advance_loc2 0x03
69 #define DW_CFA_advance_loc4 0x04
70 #define DW_CFA_offset_extended 0x05
71 #define DW_CFA_restore_extended 0x06
72 #define DW_CFA_undefined 0x07
73 #define DW_CFA_same_value 0x08
74 #define DW_CFA_register 0x09
75 #define DW_CFA_remember_state 0x0a
76 #define DW_CFA_restore_state 0x0b
77 #define DW_CFA_def_cfa 0x0c
78 #define DW_CFA_def_cfa_register 0x0d
79 #define DW_CFA_def_cfa_offset 0x0e
80 #define DW_CFA_def_cfa_expression 0x0f
81 #define DW_CFA_expression 0x10
82 #define DW_CFA_offset_extended_sf 0x11
83 #define DW_CFA_def_cfa_sf 0x12
84 #define DW_CFA_def_cfa_offset_sf 0x13
85 #define DW_CFA_val_offset 0x14
86 #define DW_CFA_val_offset_sf 0x15
87 #define DW_CFA_val_expression 0x16
88 #define DW_CFA_lo_user 0x1c
89 #define DW_CFA_GNU_window_save 0x2d
90 #define DW_CFA_GNU_args_size 0x2e
91 #define DW_CFA_GNU_negative_offset_extended 0x2f
92 #define DW_CFA_hi_user 0x3f
94 #define DW_EH_PE_FORM 0x07
95 #define DW_EH_PE_native 0x00
96 #define DW_EH_PE_leb128 0x01
97 #define DW_EH_PE_data2 0x02
98 #define DW_EH_PE_data4 0x03
99 #define DW_EH_PE_data8 0x04
100 #define DW_EH_PE_signed 0x08
101 #define DW_EH_PE_ADJUST 0x70
102 #define DW_EH_PE_abs 0x00
103 #define DW_EH_PE_pcrel 0x10
104 #define DW_EH_PE_textrel 0x20
105 #define DW_EH_PE_datarel 0x30
106 #define DW_EH_PE_funcrel 0x40
107 #define DW_EH_PE_aligned 0x50
108 #define DW_EH_PE_indirect 0x80
109 #define DW_EH_PE_omit 0xff
113 typedef unsigned long uleb128_t;
114 typedef signed long sleb128_t;
116 static struct unwind_table {
123 const unsigned char *header;
125 struct unwind_table *link;
139 struct unwind_state {
141 const u8 *cieStart, *cieEnd;
147 struct unwind_item regs[ARRAY_SIZE(reg_info)];
148 unsigned stackDepth:8;
151 const u8 *stack[MAX_STACK_DEPTH];
154 static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 };
156 static struct unwind_table *find_table(unsigned long pc)
158 struct unwind_table *table;
160 for (table = &root_table; table; table = table->link)
161 if ((pc >= table->core.pc
162 && pc < table->core.pc + table->core.range)
163 || (pc >= table->init.pc
164 && pc < table->init.pc + table->init.range))
170 static unsigned long read_pointer(const u8 **pLoc,
171 const void *end, signed ptrType);
172 static void init_unwind_hdr(struct unwind_table *table,
173 void *(*alloc) (unsigned long));
176 * wrappers for header alloc (vs. calling one vs. other at call site)
177 * to elide section mismatches warnings
179 static void *__init unw_hdr_alloc_early(unsigned long sz)
181 return memblock_alloc_from(sz, sizeof(unsigned int), MAX_DMA_ADDRESS);
184 static void init_unwind_table(struct unwind_table *table, const char *name,
185 const void *core_start, unsigned long core_size,
186 const void *init_start, unsigned long init_size,
187 const void *table_start, unsigned long table_size,
188 const u8 *header_start, unsigned long header_size)
190 table->core.pc = (unsigned long)core_start;
191 table->core.range = core_size;
192 table->init.pc = (unsigned long)init_start;
193 table->init.range = init_size;
194 table->address = table_start;
195 table->size = table_size;
196 /* To avoid the pointer addition with NULL pointer.*/
197 if (header_start != NULL) {
198 const u8 *ptr = header_start + 4;
199 const u8 *end = header_start + header_size;
200 /* See if the linker provided table looks valid. */
202 || header_start[0] != 1
203 || (void *)read_pointer(&ptr, end, header_start[1])
205 || header_start[2] == DW_EH_PE_omit
206 || read_pointer(&ptr, end, header_start[2]) <= 0
207 || header_start[3] == DW_EH_PE_omit)
210 table->hdrsz = header_size;
212 table->header = header_start;
217 void __init arc_unwind_init(void)
219 init_unwind_table(&root_table, "kernel", _text, _end - _text, NULL, 0,
220 __start_unwind, __end_unwind - __start_unwind,
222 /*__start_unwind_hdr, __end_unwind_hdr - __start_unwind_hdr);*/
224 init_unwind_hdr(&root_table, unw_hdr_alloc_early);
227 static const u32 bad_cie, not_fde;
228 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *);
229 static const u32 *__cie_for_fde(const u32 *fde);
230 static signed fde_pointer_type(const u32 *cie);
232 struct eh_frame_hdr_table_entry {
233 unsigned long start, fde;
236 static int cmp_eh_frame_hdr_table_entries(const void *p1, const void *p2)
238 const struct eh_frame_hdr_table_entry *e1 = p1;
239 const struct eh_frame_hdr_table_entry *e2 = p2;
241 return (e1->start > e2->start) - (e1->start < e2->start);
244 static void swap_eh_frame_hdr_table_entries(void *p1, void *p2, int size)
246 struct eh_frame_hdr_table_entry *e1 = p1;
247 struct eh_frame_hdr_table_entry *e2 = p2;
249 swap(e1->start, e2->start);
250 swap(e1->fde, e2->fde);
253 static void init_unwind_hdr(struct unwind_table *table,
254 void *(*alloc) (unsigned long))
257 unsigned long tableSize = table->size, hdrSize;
265 unsigned long eh_frame_ptr;
266 unsigned int fde_count;
267 struct eh_frame_hdr_table_entry table[];
268 } __attribute__ ((__packed__)) *header;
274 pr_warn(".eh_frame_hdr for '%s' present but unusable\n",
277 if (tableSize & (sizeof(*fde) - 1))
280 for (fde = table->address, n = 0;
281 tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde;
282 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
283 const u32 *cie = cie_for_fde(fde, table);
288 if (cie == NULL || cie == &bad_cie)
290 ptrType = fde_pointer_type(cie);
294 ptr = (const u8 *)(fde + 2);
295 if (!read_pointer(&ptr, (const u8 *)(fde + 1) + *fde,
297 /* FIXME_Rajesh We have 4 instances of null addresses
298 * instead of the initial loc addr
301 WARN(1, "unwinder: FDE->initial_location NULL %p\n",
302 (const u8 *)(fde + 1) + *fde);
310 hdrSize = 4 + sizeof(unsigned long) + sizeof(unsigned int)
311 + 2 * n * sizeof(unsigned long);
313 header = alloc(hdrSize);
318 header->eh_frame_ptr_enc = DW_EH_PE_abs | DW_EH_PE_native;
319 header->fde_count_enc = DW_EH_PE_abs | DW_EH_PE_data4;
320 header->table_enc = DW_EH_PE_abs | DW_EH_PE_native;
321 put_unaligned((unsigned long)table->address, &header->eh_frame_ptr);
322 BUILD_BUG_ON(offsetof(typeof(*header), fde_count)
323 % __alignof(typeof(header->fde_count)));
324 header->fde_count = n;
326 BUILD_BUG_ON(offsetof(typeof(*header), table)
327 % __alignof(typeof(*header->table)));
328 for (fde = table->address, tableSize = table->size, n = 0;
330 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
331 const u32 *cie = __cie_for_fde(fde);
333 if (fde[1] == CIE_ID)
334 continue; /* this is a CIE */
335 ptr = (const u8 *)(fde + 2);
336 header->table[n].start = read_pointer(&ptr,
337 (const u8 *)(fde + 1) +
339 fde_pointer_type(cie));
340 header->table[n].fde = (unsigned long)fde;
343 WARN_ON(n != header->fde_count);
347 sizeof(*header->table),
348 cmp_eh_frame_hdr_table_entries, swap_eh_frame_hdr_table_entries);
350 table->hdrsz = hdrSize;
352 table->header = (const void *)header;
356 panic("Attention !!! Dwarf FDE parsing errors\n");
359 #ifdef CONFIG_MODULES
360 static void *unw_hdr_alloc(unsigned long sz)
362 return kmalloc(sz, GFP_KERNEL);
365 static struct unwind_table *last_table;
367 /* Must be called with module_mutex held. */
368 void *unwind_add_table(struct module *module, const void *table_start,
369 unsigned long table_size)
371 struct unwind_table *table;
376 table = kmalloc(sizeof(*table), GFP_KERNEL);
380 init_unwind_table(table, module->name,
381 module->core_layout.base, module->core_layout.size,
382 module->init_layout.base, module->init_layout.size,
383 table_start, table_size,
386 init_unwind_hdr(table, unw_hdr_alloc);
389 unw_debug("Table added for [%s] %lx %lx\n",
390 module->name, table->core.pc, table->core.range);
393 last_table->link = table;
395 root_table.link = table;
401 struct unlink_table_info {
402 struct unwind_table *table;
406 static int unlink_table(void *arg)
408 struct unlink_table_info *info = arg;
409 struct unwind_table *table = info->table, *prev;
411 for (prev = &root_table; prev->link && prev->link != table;
416 if (info->init_only) {
418 table->init.range = 0;
421 prev->link = table->link;
431 /* Must be called with module_mutex held. */
432 void unwind_remove_table(void *handle, int init_only)
434 struct unwind_table *table = handle;
435 struct unlink_table_info info;
437 if (!table || table == &root_table)
440 if (init_only && table == last_table) {
442 table->init.range = 0;
447 info.init_only = init_only;
449 unlink_table(&info); /* XXX: SMP */
450 kfree(table->header);
454 #endif /* CONFIG_MODULES */
456 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end)
458 const u8 *cur = *pcur;
462 for (shift = 0, value = 0; cur < end; shift += 7) {
463 if (shift + 7 > 8 * sizeof(value)
464 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
468 value |= (uleb128_t) (*cur & 0x7f) << shift;
469 if (!(*cur++ & 0x80))
477 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end)
479 const u8 *cur = *pcur;
483 for (shift = 0, value = 0; cur < end; shift += 7) {
484 if (shift + 7 > 8 * sizeof(value)
485 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
489 value |= (sleb128_t) (*cur & 0x7f) << shift;
490 if (!(*cur & 0x80)) {
491 value |= -(*cur++ & 0x40) << shift;
500 static const u32 *__cie_for_fde(const u32 *fde)
504 cie = fde + 1 - fde[1] / sizeof(*fde);
509 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *table)
513 if (!*fde || (*fde & (sizeof(*fde) - 1)))
516 if (fde[1] == CIE_ID)
517 return ¬_fde; /* this is a CIE */
519 if ((fde[1] & (sizeof(*fde) - 1)))
520 /* || fde[1] > (unsigned long)(fde + 1) - (unsigned long)table->address) */
521 return NULL; /* this is not a valid FDE */
523 cie = __cie_for_fde(fde);
525 if (*cie <= sizeof(*cie) + 4 || *cie >= fde[1] - sizeof(*fde)
526 || (*cie & (sizeof(*cie) - 1))
527 || (cie[1] != CIE_ID))
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));
572 case DW_EH_PE_native:
573 if (end < (const void *)(ptr.pul + 1))
575 value = get_unaligned((unsigned long *)ptr.pul++);
577 case DW_EH_PE_leb128:
578 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value));
579 value = ptrType & DW_EH_PE_signed ? get_sleb128(&ptr.p8, end)
580 : get_uleb128(&ptr.p8, end);
581 if ((const void *)ptr.p8 > end)
587 switch (ptrType & DW_EH_PE_ADJUST) {
591 value += (unsigned long)*pLoc;
596 if ((ptrType & DW_EH_PE_indirect)
597 && __get_user(value, (unsigned long __user *)value))
604 static signed fde_pointer_type(const u32 *cie)
606 const u8 *ptr = (const u8 *)(cie + 2);
607 unsigned int version = *ptr;
611 const u8 *end = (const u8 *)(cie + 1) + *cie;
614 /* check if augmentation size is first (and thus present) */
618 /* check if augmentation string is nul-terminated */
619 aug = (const void *)ptr;
620 ptr = memchr(aug, 0, end - ptr);
624 ++ptr; /* skip terminator */
625 get_uleb128(&ptr, end); /* skip code alignment */
626 get_sleb128(&ptr, end); /* skip data alignment */
627 /* skip return address column */
628 version <= 1 ? (void) ++ptr : (void)get_uleb128(&ptr, end);
629 len = get_uleb128(&ptr, end); /* augmentation length */
631 if (ptr + len < ptr || ptr + len > end)
643 signed ptrType = *ptr++;
645 if (!read_pointer(&ptr, end, ptrType)
657 return DW_EH_PE_native | DW_EH_PE_abs;
660 static int advance_loc(unsigned long delta, struct unwind_state *state)
662 state->loc += delta * state->codeAlign;
664 /* FIXME_Rajesh: Probably we are defining for the initial range as well;
667 unw_debug("delta %3lu => loc 0x%lx: ", delta, state->loc);
671 static void set_rule(uleb128_t reg, enum item_location where, uleb128_t value,
672 struct unwind_state *state)
674 if (reg < ARRAY_SIZE(state->regs)) {
675 state->regs[reg].where = where;
676 state->regs[reg].value = value;
679 unw_debug("r%lu: ", reg);
685 unw_debug("c(%lu) ", value);
688 unw_debug("r(%lu) ", value);
691 unw_debug("v(%lu) ", value);
700 static int processCFI(const u8 *start, const u8 *end, unsigned long targetLoc,
701 signed ptrType, struct unwind_state *state)
711 if (start != state->cieStart) {
712 state->loc = state->org;
714 processCFI(state->cieStart, state->cieEnd, 0, ptrType,
716 if (targetLoc == 0 && state->label == NULL)
719 for (ptr.p8 = start; result && ptr.p8 < end;) {
720 switch (*ptr.p8 >> 6) {
728 unw_debug("cfa nop ");
731 state->loc = read_pointer(&ptr.p8, end,
735 unw_debug("cfa_set_loc: 0x%lx ", state->loc);
737 case DW_CFA_advance_loc1:
738 unw_debug("\ncfa advance loc1:");
739 result = ptr.p8 < end
740 && advance_loc(*ptr.p8++, state);
742 case DW_CFA_advance_loc2:
744 value += *ptr.p8++ << 8;
745 unw_debug("\ncfa advance loc2:");
746 result = ptr.p8 <= end + 2
747 /* && advance_loc(*ptr.p16++, state); */
748 && advance_loc(value, state);
750 case DW_CFA_advance_loc4:
751 unw_debug("\ncfa advance loc4:");
752 result = ptr.p8 <= end + 4
753 && advance_loc(*ptr.p32++, state);
755 case DW_CFA_offset_extended:
756 value = get_uleb128(&ptr.p8, end);
757 unw_debug("cfa_offset_extended: ");
758 set_rule(value, Memory,
759 get_uleb128(&ptr.p8, end), state);
761 case DW_CFA_val_offset:
762 value = get_uleb128(&ptr.p8, end);
763 set_rule(value, Value,
764 get_uleb128(&ptr.p8, end), state);
766 case DW_CFA_offset_extended_sf:
767 value = get_uleb128(&ptr.p8, end);
768 set_rule(value, Memory,
769 get_sleb128(&ptr.p8, end), state);
771 case DW_CFA_val_offset_sf:
772 value = get_uleb128(&ptr.p8, end);
773 set_rule(value, Value,
774 get_sleb128(&ptr.p8, end), state);
776 case DW_CFA_restore_extended:
777 unw_debug("cfa_restore_extended: ");
778 case DW_CFA_undefined:
779 unw_debug("cfa_undefined: ");
780 case DW_CFA_same_value:
781 unw_debug("cfa_same_value: ");
782 set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0,
785 case DW_CFA_register:
786 unw_debug("cfa_register: ");
787 value = get_uleb128(&ptr.p8, end);
790 get_uleb128(&ptr.p8, end), state);
792 case DW_CFA_remember_state:
793 unw_debug("cfa_remember_state: ");
794 if (ptr.p8 == state->label) {
798 if (state->stackDepth >= MAX_STACK_DEPTH)
800 state->stack[state->stackDepth++] = ptr.p8;
802 case DW_CFA_restore_state:
803 unw_debug("cfa_restore_state: ");
804 if (state->stackDepth) {
805 const uleb128_t loc = state->loc;
806 const u8 *label = state->label;
809 state->stack[state->stackDepth - 1];
810 memcpy(&state->cfa, &badCFA,
812 memset(state->regs, 0,
813 sizeof(state->regs));
814 state->stackDepth = 0;
816 processCFI(start, end, 0, ptrType,
819 state->label = label;
824 state->cfa.reg = get_uleb128(&ptr.p8, end);
825 unw_debug("cfa_def_cfa: r%lu ", state->cfa.reg);
827 case DW_CFA_def_cfa_offset:
828 state->cfa.offs = get_uleb128(&ptr.p8, end);
829 unw_debug("cfa_def_cfa_offset: 0x%lx ",
832 case DW_CFA_def_cfa_sf:
833 state->cfa.reg = get_uleb128(&ptr.p8, end);
835 case DW_CFA_def_cfa_offset_sf:
836 state->cfa.offs = get_sleb128(&ptr.p8, end)
839 case DW_CFA_def_cfa_register:
840 unw_debug("cfa_def_cfa_register: ");
841 state->cfa.reg = get_uleb128(&ptr.p8, end);
843 /*todo case DW_CFA_def_cfa_expression: */
844 /*todo case DW_CFA_expression: */
845 /*todo case DW_CFA_val_expression: */
846 case DW_CFA_GNU_args_size:
847 get_uleb128(&ptr.p8, end);
849 case DW_CFA_GNU_negative_offset_extended:
850 value = get_uleb128(&ptr.p8, end);
853 (uleb128_t) 0 - get_uleb128(&ptr.p8,
857 case DW_CFA_GNU_window_save:
859 unw_debug("UNKNOWN OPCODE 0x%x\n", opcode);
865 unw_debug("\ncfa_adv_loc: ");
866 result = advance_loc(*ptr.p8++ & 0x3f, state);
869 unw_debug("cfa_offset: ");
870 value = *ptr.p8++ & 0x3f;
871 set_rule(value, Memory, get_uleb128(&ptr.p8, end),
875 unw_debug("cfa_restore: ");
876 set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state);
882 if (result && targetLoc != 0 && targetLoc < state->loc)
886 return result && ptr.p8 == end && (targetLoc == 0 || (
887 /*todo While in theory this should apply, gcc in practice omits
888 everything past the function prolog, and hence the location
889 never reaches the end of the function.
890 targetLoc < state->loc && */ state->label == NULL));
893 /* Unwind to previous to frame. Returns 0 if successful, negative
894 * number in case of an error. */
895 int arc_unwind(struct unwind_frame_info *frame)
897 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
898 const u32 *fde = NULL, *cie = NULL;
899 const u8 *ptr = NULL, *end = NULL;
900 unsigned long pc = UNW_PC(frame) - frame->call_frame;
901 unsigned long startLoc = 0, endLoc = 0, cfa;
904 uleb128_t retAddrReg = 0;
905 const struct unwind_table *table;
906 struct unwind_state state;
910 unw_debug("\n\nUNWIND FRAME:\n");
911 unw_debug("PC: 0x%lx BLINK: 0x%lx, SP: 0x%lx, FP: 0x%x\n",
912 UNW_PC(frame), UNW_BLINK(frame), UNW_SP(frame),
915 if (UNW_PC(frame) == 0)
920 unsigned long *sptr = (unsigned long *)UNW_SP(frame);
921 unw_debug("\nStack Dump:\n");
922 for (i = 0; i < 20; i++, sptr++)
923 unw_debug("0x%p: 0x%lx\n", sptr, *sptr);
928 table = find_table(pc);
930 && !(table->size & (sizeof(*fde) - 1))) {
931 const u8 *hdr = table->header;
932 unsigned long tableSize;
935 if (hdr && hdr[0] == 1) {
936 switch (hdr[3] & DW_EH_PE_FORM) {
937 case DW_EH_PE_native:
938 tableSize = sizeof(unsigned long);
954 end = hdr + table->hdrsz;
955 if (tableSize && read_pointer(&ptr, end, hdr[1])
956 == (unsigned long)table->address
957 && (i = read_pointer(&ptr, end, hdr[2])) > 0
958 && i == (end - ptr) / (2 * tableSize)
959 && !((end - ptr) % (2 * tableSize))) {
962 ptr + (i / 2) * (2 * tableSize);
964 startLoc = read_pointer(&cur,
970 ptr = cur - tableSize;
973 } while (startLoc && i > 1);
975 && (startLoc = read_pointer(&ptr,
979 fde = (void *)read_pointer(&ptr,
987 cie = cie_for_fde(fde, table);
988 ptr = (const u8 *)(fde + 2);
992 && (ptrType = fde_pointer_type(cie)) >= 0
993 && read_pointer(&ptr,
994 (const u8 *)(fde + 1) + *fde,
995 ptrType) == startLoc) {
996 if (!(ptrType & DW_EH_PE_indirect))
998 DW_EH_PE_FORM | DW_EH_PE_signed;
1000 startLoc + read_pointer(&ptr,
1015 memset(&state, 0, sizeof(state));
1016 state.cieEnd = ptr; /* keep here temporarily */
1017 ptr = (const u8 *)(cie + 2);
1018 end = (const u8 *)(cie + 1) + *cie;
1019 frame->call_frame = 1;
1021 /* check if augmentation size is first (thus present) */
1023 while (++ptr < end && *ptr) {
1025 /* chk for ignorable or already handled
1026 * nul-terminated augmentation string */
1032 frame->call_frame = 0;
1040 if (ptr >= end || *ptr)
1046 /* get code alignment factor */
1047 state.codeAlign = get_uleb128(&ptr, end);
1048 /* get data alignment factor */
1049 state.dataAlign = get_sleb128(&ptr, end);
1050 if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end)
1054 state.version <= 1 ? *ptr++ : get_uleb128(&ptr,
1056 unw_debug("CIE Frame Info:\n");
1057 unw_debug("return Address register 0x%lx\n",
1059 unw_debug("data Align: %ld\n", state.dataAlign);
1060 unw_debug("code Align: %lu\n", state.codeAlign);
1061 /* skip augmentation */
1062 if (((const char *)(cie + 2))[1] == 'z') {
1063 uleb128_t augSize = get_uleb128(&ptr, end);
1067 if (ptr > end || retAddrReg >= ARRAY_SIZE(reg_info)
1068 || REG_INVALID(retAddrReg)
1069 || reg_info[retAddrReg].width !=
1070 sizeof(unsigned long))
1075 state.cieStart = ptr;
1078 end = (const u8 *)(fde + 1) + *fde;
1079 /* skip augmentation */
1080 if (((const char *)(cie + 2))[1] == 'z') {
1081 uleb128_t augSize = get_uleb128(&ptr, end);
1083 if ((ptr += augSize) > end)
1087 if (cie == NULL || fde == NULL) {
1088 #ifdef CONFIG_FRAME_POINTER
1089 unsigned long top, bottom;
1091 top = STACK_TOP_UNW(frame->task);
1092 bottom = STACK_BOTTOM_UNW(frame->task);
1093 #if FRAME_RETADDR_OFFSET < 0
1094 if (UNW_SP(frame) < top && UNW_FP(frame) <= UNW_SP(frame)
1095 && bottom < UNW_FP(frame)
1097 if (UNW_SP(frame) > top && UNW_FP(frame) >= UNW_SP(frame)
1098 && bottom > UNW_FP(frame)
1100 && !((UNW_SP(frame) | UNW_FP(frame))
1101 & (sizeof(unsigned long) - 1))) {
1104 if (!__get_user(link, (unsigned long *)
1105 (UNW_FP(frame) + FRAME_LINK_OFFSET))
1106 #if FRAME_RETADDR_OFFSET < 0
1107 && link > bottom && link < UNW_FP(frame)
1109 && link > UNW_FP(frame) && link < bottom
1111 && !(link & (sizeof(link) - 1))
1112 && !__get_user(UNW_PC(frame),
1113 (unsigned long *)(UNW_FP(frame)
1114 + FRAME_RETADDR_OFFSET)))
1117 UNW_FP(frame) + FRAME_RETADDR_OFFSET
1118 #if FRAME_RETADDR_OFFSET < 0
1123 sizeof(UNW_PC(frame));
1124 UNW_FP(frame) = link;
1131 state.org = startLoc;
1132 memcpy(&state.cfa, &badCFA, sizeof(state.cfa));
1134 unw_debug("\nProcess instructions\n");
1136 /* process instructions
1137 * For ARC, we optimize by having blink(retAddrReg) with
1138 * the sameValue in the leaf function, so we should not check
1139 * state.regs[retAddrReg].where == Nowhere
1141 if (!processCFI(ptr, end, pc, ptrType, &state)
1142 || state.loc > endLoc
1143 /* || state.regs[retAddrReg].where == Nowhere */
1144 || state.cfa.reg >= ARRAY_SIZE(reg_info)
1145 || reg_info[state.cfa.reg].width != sizeof(unsigned long)
1146 || state.cfa.offs % sizeof(unsigned long))
1152 unw_debug("\nRegister State Based on the rules parsed from FDE:\n");
1153 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1158 switch (state.regs[i].where) {
1162 unw_debug(" r%d: c(%lu),", i, state.regs[i].value);
1165 unw_debug(" r%d: r(%lu),", i, state.regs[i].value);
1168 unw_debug(" r%d: v(%lu),", i, state.regs[i].value);
1177 if (frame->call_frame
1178 && !UNW_DEFAULT_RA(state.regs[retAddrReg], state.dataAlign))
1179 frame->call_frame = 0;
1180 cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs;
1181 startLoc = min_t(unsigned long, UNW_SP(frame), cfa);
1182 endLoc = max_t(unsigned long, UNW_SP(frame), cfa);
1183 if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
1184 startLoc = min(STACK_LIMIT(cfa), cfa);
1185 endLoc = max(STACK_LIMIT(cfa), cfa);
1188 unw_debug("\nCFA reg: 0x%lx, offset: 0x%lx => 0x%lx\n",
1189 state.cfa.reg, state.cfa.offs, cfa);
1191 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1192 if (REG_INVALID(i)) {
1193 if (state.regs[i].where == Nowhere)
1197 switch (state.regs[i].where) {
1201 if (state.regs[i].value >= ARRAY_SIZE(reg_info)
1202 || REG_INVALID(state.regs[i].value)
1203 || reg_info[i].width >
1204 reg_info[state.regs[i].value].width)
1206 switch (reg_info[state.regs[i].value].width) {
1208 state.regs[i].value =
1209 FRAME_REG(state.regs[i].value, const u8);
1212 state.regs[i].value =
1213 FRAME_REG(state.regs[i].value, const u16);
1216 state.regs[i].value =
1217 FRAME_REG(state.regs[i].value, const u32);
1221 state.regs[i].value =
1222 FRAME_REG(state.regs[i].value, const u64);
1232 unw_debug("\nRegister state after evaluation with realtime Stack:\n");
1233 fptr = (unsigned long *)(&frame->regs);
1234 for (i = 0; i < ARRAY_SIZE(state.regs); ++i, fptr++) {
1238 switch (state.regs[i].where) {
1240 if (reg_info[i].width != sizeof(UNW_SP(frame))
1241 || &FRAME_REG(i, __typeof__(UNW_SP(frame)))
1244 UNW_SP(frame) = cfa;
1247 switch (reg_info[i].width) {
1249 FRAME_REG(i, u8) = state.regs[i].value;
1252 FRAME_REG(i, u16) = state.regs[i].value;
1255 FRAME_REG(i, u32) = state.regs[i].value;
1259 FRAME_REG(i, u64) = state.regs[i].value;
1267 if (reg_info[i].width != sizeof(unsigned long))
1269 FRAME_REG(i, unsigned long) = cfa + state.regs[i].value
1273 addr = cfa + state.regs[i].value * state.dataAlign;
1275 if ((state.regs[i].value * state.dataAlign)
1276 % sizeof(unsigned long)
1278 || addr + sizeof(unsigned long) < addr
1279 || addr + sizeof(unsigned long) > endLoc)
1282 switch (reg_info[i].width) {
1284 __get_user(FRAME_REG(i, u8),
1288 __get_user(FRAME_REG(i, u16),
1289 (u16 __user *)addr);
1292 __get_user(FRAME_REG(i, u32),
1293 (u32 __user *)addr);
1297 __get_user(FRAME_REG(i, u64),
1298 (u64 __user *)addr);
1307 unw_debug("r%d: 0x%lx ", i, *fptr);
1313 EXPORT_SYMBOL(arc_unwind);