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 % FIELD_SIZEOF(struct unwind_frame_info, f)) \
46 + offsetof(struct unwind_frame_info, f) \
47 / FIELD_SIZEOF(struct unwind_frame_info, f), \
48 FIELD_SIZEOF(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 const u8 *ptr = header_start + 4;
191 const u8 *end = header_start + header_size;
193 table->core.pc = (unsigned long)core_start;
194 table->core.range = core_size;
195 table->init.pc = (unsigned long)init_start;
196 table->init.range = init_size;
197 table->address = table_start;
198 table->size = table_size;
200 /* See if the linker provided table looks valid. */
202 || header_start[0] != 1
203 || (void *)read_pointer(&ptr, end, header_start[1]) != table_start
204 || header_start[2] == DW_EH_PE_omit
205 || read_pointer(&ptr, end, header_start[2]) <= 0
206 || header_start[3] == DW_EH_PE_omit)
209 table->hdrsz = header_size;
211 table->header = header_start;
216 void __init arc_unwind_init(void)
218 init_unwind_table(&root_table, "kernel", _text, _end - _text, NULL, 0,
219 __start_unwind, __end_unwind - __start_unwind,
221 /*__start_unwind_hdr, __end_unwind_hdr - __start_unwind_hdr);*/
223 init_unwind_hdr(&root_table, unw_hdr_alloc_early);
226 static const u32 bad_cie, not_fde;
227 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *);
228 static const u32 *__cie_for_fde(const u32 *fde);
229 static signed fde_pointer_type(const u32 *cie);
231 struct eh_frame_hdr_table_entry {
232 unsigned long start, fde;
235 static int cmp_eh_frame_hdr_table_entries(const void *p1, const void *p2)
237 const struct eh_frame_hdr_table_entry *e1 = p1;
238 const struct eh_frame_hdr_table_entry *e2 = p2;
240 return (e1->start > e2->start) - (e1->start < e2->start);
243 static void swap_eh_frame_hdr_table_entries(void *p1, void *p2, int size)
245 struct eh_frame_hdr_table_entry *e1 = p1;
246 struct eh_frame_hdr_table_entry *e2 = p2;
250 e1->start = e2->start;
257 static void init_unwind_hdr(struct unwind_table *table,
258 void *(*alloc) (unsigned long))
261 unsigned long tableSize = table->size, hdrSize;
269 unsigned long eh_frame_ptr;
270 unsigned int fde_count;
271 struct eh_frame_hdr_table_entry table[];
272 } __attribute__ ((__packed__)) *header;
278 pr_warn(".eh_frame_hdr for '%s' present but unusable\n",
281 if (tableSize & (sizeof(*fde) - 1))
284 for (fde = table->address, n = 0;
285 tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde;
286 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
287 const u32 *cie = cie_for_fde(fde, table);
292 if (cie == NULL || cie == &bad_cie)
294 ptrType = fde_pointer_type(cie);
298 ptr = (const u8 *)(fde + 2);
299 if (!read_pointer(&ptr, (const u8 *)(fde + 1) + *fde,
301 /* FIXME_Rajesh We have 4 instances of null addresses
302 * instead of the initial loc addr
305 WARN(1, "unwinder: FDE->initial_location NULL %p\n",
306 (const u8 *)(fde + 1) + *fde);
314 hdrSize = 4 + sizeof(unsigned long) + sizeof(unsigned int)
315 + 2 * n * sizeof(unsigned long);
317 header = alloc(hdrSize);
322 header->eh_frame_ptr_enc = DW_EH_PE_abs | DW_EH_PE_native;
323 header->fde_count_enc = DW_EH_PE_abs | DW_EH_PE_data4;
324 header->table_enc = DW_EH_PE_abs | DW_EH_PE_native;
325 put_unaligned((unsigned long)table->address, &header->eh_frame_ptr);
326 BUILD_BUG_ON(offsetof(typeof(*header), fde_count)
327 % __alignof(typeof(header->fde_count)));
328 header->fde_count = n;
330 BUILD_BUG_ON(offsetof(typeof(*header), table)
331 % __alignof(typeof(*header->table)));
332 for (fde = table->address, tableSize = table->size, n = 0;
334 tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
335 const u32 *cie = __cie_for_fde(fde);
337 if (fde[1] == CIE_ID)
338 continue; /* this is a CIE */
339 ptr = (const u8 *)(fde + 2);
340 header->table[n].start = read_pointer(&ptr,
341 (const u8 *)(fde + 1) +
343 fde_pointer_type(cie));
344 header->table[n].fde = (unsigned long)fde;
347 WARN_ON(n != header->fde_count);
351 sizeof(*header->table),
352 cmp_eh_frame_hdr_table_entries, swap_eh_frame_hdr_table_entries);
354 table->hdrsz = hdrSize;
356 table->header = (const void *)header;
360 panic("Attention !!! Dwarf FDE parsing errors\n");
363 #ifdef CONFIG_MODULES
364 static void *unw_hdr_alloc(unsigned long sz)
366 return kmalloc(sz, GFP_KERNEL);
369 static struct unwind_table *last_table;
371 /* Must be called with module_mutex held. */
372 void *unwind_add_table(struct module *module, const void *table_start,
373 unsigned long table_size)
375 struct unwind_table *table;
380 table = kmalloc(sizeof(*table), GFP_KERNEL);
384 init_unwind_table(table, module->name,
385 module->core_layout.base, module->core_layout.size,
386 module->init_layout.base, module->init_layout.size,
387 table_start, table_size,
390 init_unwind_hdr(table, unw_hdr_alloc);
393 unw_debug("Table added for [%s] %lx %lx\n",
394 module->name, table->core.pc, table->core.range);
397 last_table->link = table;
399 root_table.link = table;
405 struct unlink_table_info {
406 struct unwind_table *table;
410 static int unlink_table(void *arg)
412 struct unlink_table_info *info = arg;
413 struct unwind_table *table = info->table, *prev;
415 for (prev = &root_table; prev->link && prev->link != table;
420 if (info->init_only) {
422 table->init.range = 0;
425 prev->link = table->link;
435 /* Must be called with module_mutex held. */
436 void unwind_remove_table(void *handle, int init_only)
438 struct unwind_table *table = handle;
439 struct unlink_table_info info;
441 if (!table || table == &root_table)
444 if (init_only && table == last_table) {
446 table->init.range = 0;
451 info.init_only = init_only;
453 unlink_table(&info); /* XXX: SMP */
454 kfree(table->header);
458 #endif /* CONFIG_MODULES */
460 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end)
462 const u8 *cur = *pcur;
466 for (shift = 0, value = 0; cur < end; shift += 7) {
467 if (shift + 7 > 8 * sizeof(value)
468 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
472 value |= (uleb128_t) (*cur & 0x7f) << shift;
473 if (!(*cur++ & 0x80))
481 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end)
483 const u8 *cur = *pcur;
487 for (shift = 0, value = 0; cur < end; shift += 7) {
488 if (shift + 7 > 8 * sizeof(value)
489 && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
493 value |= (sleb128_t) (*cur & 0x7f) << shift;
494 if (!(*cur & 0x80)) {
495 value |= -(*cur++ & 0x40) << shift;
504 static const u32 *__cie_for_fde(const u32 *fde)
508 cie = fde + 1 - fde[1] / sizeof(*fde);
513 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *table)
517 if (!*fde || (*fde & (sizeof(*fde) - 1)))
520 if (fde[1] == CIE_ID)
521 return ¬_fde; /* this is a CIE */
523 if ((fde[1] & (sizeof(*fde) - 1)))
524 /* || fde[1] > (unsigned long)(fde + 1) - (unsigned long)table->address) */
525 return NULL; /* this is not a valid FDE */
527 cie = __cie_for_fde(fde);
529 if (*cie <= sizeof(*cie) + 4 || *cie >= fde[1] - sizeof(*fde)
530 || (*cie & (sizeof(*cie) - 1))
531 || (cie[1] != CIE_ID))
532 return NULL; /* this is not a (valid) CIE */
536 static unsigned long read_pointer(const u8 **pLoc, const void *end,
539 unsigned long value = 0;
546 const unsigned long *pul;
549 if (ptrType < 0 || ptrType == DW_EH_PE_omit)
552 switch (ptrType & DW_EH_PE_FORM) {
554 if (end < (const void *)(ptr.p16u + 1))
556 if (ptrType & DW_EH_PE_signed)
557 value = get_unaligned((u16 *) ptr.p16s++);
559 value = get_unaligned((u16 *) ptr.p16u++);
563 if (end < (const void *)(ptr.p32u + 1))
565 if (ptrType & DW_EH_PE_signed)
566 value = get_unaligned(ptr.p32s++);
568 value = get_unaligned(ptr.p32u++);
571 BUILD_BUG_ON(sizeof(u64) != sizeof(value));
573 BUILD_BUG_ON(sizeof(u32) != sizeof(value));
575 case DW_EH_PE_native:
576 if (end < (const void *)(ptr.pul + 1))
578 value = get_unaligned((unsigned long *)ptr.pul++);
580 case DW_EH_PE_leb128:
581 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value));
582 value = ptrType & DW_EH_PE_signed ? get_sleb128(&ptr.p8, end)
583 : get_uleb128(&ptr.p8, end);
584 if ((const void *)ptr.p8 > end)
590 switch (ptrType & DW_EH_PE_ADJUST) {
594 value += (unsigned long)*pLoc;
599 if ((ptrType & DW_EH_PE_indirect)
600 && __get_user(value, (unsigned long __user *)value))
607 static signed fde_pointer_type(const u32 *cie)
609 const u8 *ptr = (const u8 *)(cie + 2);
610 unsigned version = *ptr;
614 const u8 *end = (const u8 *)(cie + 1) + *cie;
617 /* check if augmentation size is first (and thus present) */
621 /* check if augmentation string is nul-terminated */
622 aug = (const void *)ptr;
623 ptr = memchr(aug, 0, end - ptr);
627 ++ptr; /* skip terminator */
628 get_uleb128(&ptr, end); /* skip code alignment */
629 get_sleb128(&ptr, end); /* skip data alignment */
630 /* skip return address column */
631 version <= 1 ? (void) ++ptr : (void)get_uleb128(&ptr, end);
632 len = get_uleb128(&ptr, end); /* augmentation length */
634 if (ptr + len < ptr || ptr + len > end)
646 signed ptrType = *ptr++;
648 if (!read_pointer(&ptr, end, ptrType)
660 return DW_EH_PE_native | DW_EH_PE_abs;
663 static int advance_loc(unsigned long delta, struct unwind_state *state)
665 state->loc += delta * state->codeAlign;
667 /* FIXME_Rajesh: Probably we are defining for the initial range as well;
670 unw_debug("delta %3lu => loc 0x%lx: ", delta, state->loc);
674 static void set_rule(uleb128_t reg, enum item_location where, uleb128_t value,
675 struct unwind_state *state)
677 if (reg < ARRAY_SIZE(state->regs)) {
678 state->regs[reg].where = where;
679 state->regs[reg].value = value;
682 unw_debug("r%lu: ", reg);
688 unw_debug("c(%lu) ", value);
691 unw_debug("r(%lu) ", value);
694 unw_debug("v(%lu) ", value);
703 static int processCFI(const u8 *start, const u8 *end, unsigned long targetLoc,
704 signed ptrType, struct unwind_state *state)
714 if (start != state->cieStart) {
715 state->loc = state->org;
717 processCFI(state->cieStart, state->cieEnd, 0, ptrType,
719 if (targetLoc == 0 && state->label == NULL)
722 for (ptr.p8 = start; result && ptr.p8 < end;) {
723 switch (*ptr.p8 >> 6) {
731 unw_debug("cfa nop ");
734 state->loc = read_pointer(&ptr.p8, end,
738 unw_debug("cfa_set_loc: 0x%lx ", state->loc);
740 case DW_CFA_advance_loc1:
741 unw_debug("\ncfa advance loc1:");
742 result = ptr.p8 < end
743 && advance_loc(*ptr.p8++, state);
745 case DW_CFA_advance_loc2:
747 value += *ptr.p8++ << 8;
748 unw_debug("\ncfa advance loc2:");
749 result = ptr.p8 <= end + 2
750 /* && advance_loc(*ptr.p16++, state); */
751 && advance_loc(value, state);
753 case DW_CFA_advance_loc4:
754 unw_debug("\ncfa advance loc4:");
755 result = ptr.p8 <= end + 4
756 && advance_loc(*ptr.p32++, state);
758 case DW_CFA_offset_extended:
759 value = get_uleb128(&ptr.p8, end);
760 unw_debug("cfa_offset_extended: ");
761 set_rule(value, Memory,
762 get_uleb128(&ptr.p8, end), state);
764 case DW_CFA_val_offset:
765 value = get_uleb128(&ptr.p8, end);
766 set_rule(value, Value,
767 get_uleb128(&ptr.p8, end), state);
769 case DW_CFA_offset_extended_sf:
770 value = get_uleb128(&ptr.p8, end);
771 set_rule(value, Memory,
772 get_sleb128(&ptr.p8, end), state);
774 case DW_CFA_val_offset_sf:
775 value = get_uleb128(&ptr.p8, end);
776 set_rule(value, Value,
777 get_sleb128(&ptr.p8, end), state);
779 case DW_CFA_restore_extended:
780 unw_debug("cfa_restore_extended: ");
781 case DW_CFA_undefined:
782 unw_debug("cfa_undefined: ");
783 case DW_CFA_same_value:
784 unw_debug("cfa_same_value: ");
785 set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0,
788 case DW_CFA_register:
789 unw_debug("cfa_register: ");
790 value = get_uleb128(&ptr.p8, end);
793 get_uleb128(&ptr.p8, end), state);
795 case DW_CFA_remember_state:
796 unw_debug("cfa_remember_state: ");
797 if (ptr.p8 == state->label) {
801 if (state->stackDepth >= MAX_STACK_DEPTH)
803 state->stack[state->stackDepth++] = ptr.p8;
805 case DW_CFA_restore_state:
806 unw_debug("cfa_restore_state: ");
807 if (state->stackDepth) {
808 const uleb128_t loc = state->loc;
809 const u8 *label = state->label;
812 state->stack[state->stackDepth - 1];
813 memcpy(&state->cfa, &badCFA,
815 memset(state->regs, 0,
816 sizeof(state->regs));
817 state->stackDepth = 0;
819 processCFI(start, end, 0, ptrType,
822 state->label = label;
827 state->cfa.reg = get_uleb128(&ptr.p8, end);
828 unw_debug("cfa_def_cfa: r%lu ", state->cfa.reg);
830 case DW_CFA_def_cfa_offset:
831 state->cfa.offs = get_uleb128(&ptr.p8, end);
832 unw_debug("cfa_def_cfa_offset: 0x%lx ",
835 case DW_CFA_def_cfa_sf:
836 state->cfa.reg = get_uleb128(&ptr.p8, end);
838 case DW_CFA_def_cfa_offset_sf:
839 state->cfa.offs = get_sleb128(&ptr.p8, end)
842 case DW_CFA_def_cfa_register:
843 unw_debug("cfa_def_cfa_register: ");
844 state->cfa.reg = get_uleb128(&ptr.p8, end);
846 /*todo case DW_CFA_def_cfa_expression: */
847 /*todo case DW_CFA_expression: */
848 /*todo case DW_CFA_val_expression: */
849 case DW_CFA_GNU_args_size:
850 get_uleb128(&ptr.p8, end);
852 case DW_CFA_GNU_negative_offset_extended:
853 value = get_uleb128(&ptr.p8, end);
856 (uleb128_t) 0 - get_uleb128(&ptr.p8,
860 case DW_CFA_GNU_window_save:
862 unw_debug("UNKNOWN OPCODE 0x%x\n", opcode);
868 unw_debug("\ncfa_adv_loc: ");
869 result = advance_loc(*ptr.p8++ & 0x3f, state);
872 unw_debug("cfa_offset: ");
873 value = *ptr.p8++ & 0x3f;
874 set_rule(value, Memory, get_uleb128(&ptr.p8, end),
878 unw_debug("cfa_restore: ");
879 set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state);
885 if (result && targetLoc != 0 && targetLoc < state->loc)
889 return result && ptr.p8 == end && (targetLoc == 0 || (
890 /*todo While in theory this should apply, gcc in practice omits
891 everything past the function prolog, and hence the location
892 never reaches the end of the function.
893 targetLoc < state->loc && */ state->label == NULL));
896 /* Unwind to previous to frame. Returns 0 if successful, negative
897 * number in case of an error. */
898 int arc_unwind(struct unwind_frame_info *frame)
900 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
901 const u32 *fde = NULL, *cie = NULL;
902 const u8 *ptr = NULL, *end = NULL;
903 unsigned long pc = UNW_PC(frame) - frame->call_frame;
904 unsigned long startLoc = 0, endLoc = 0, cfa;
907 uleb128_t retAddrReg = 0;
908 const struct unwind_table *table;
909 struct unwind_state state;
913 unw_debug("\n\nUNWIND FRAME:\n");
914 unw_debug("PC: 0x%lx BLINK: 0x%lx, SP: 0x%lx, FP: 0x%x\n",
915 UNW_PC(frame), UNW_BLINK(frame), UNW_SP(frame),
918 if (UNW_PC(frame) == 0)
923 unsigned long *sptr = (unsigned long *)UNW_SP(frame);
924 unw_debug("\nStack Dump:\n");
925 for (i = 0; i < 20; i++, sptr++)
926 unw_debug("0x%p: 0x%lx\n", sptr, *sptr);
931 table = find_table(pc);
933 && !(table->size & (sizeof(*fde) - 1))) {
934 const u8 *hdr = table->header;
935 unsigned long tableSize;
938 if (hdr && hdr[0] == 1) {
939 switch (hdr[3] & DW_EH_PE_FORM) {
940 case DW_EH_PE_native:
941 tableSize = sizeof(unsigned long);
957 end = hdr + table->hdrsz;
958 if (tableSize && read_pointer(&ptr, end, hdr[1])
959 == (unsigned long)table->address
960 && (i = read_pointer(&ptr, end, hdr[2])) > 0
961 && i == (end - ptr) / (2 * tableSize)
962 && !((end - ptr) % (2 * tableSize))) {
965 ptr + (i / 2) * (2 * tableSize);
967 startLoc = read_pointer(&cur,
973 ptr = cur - tableSize;
976 } while (startLoc && i > 1);
978 && (startLoc = read_pointer(&ptr,
982 fde = (void *)read_pointer(&ptr,
990 cie = cie_for_fde(fde, table);
991 ptr = (const u8 *)(fde + 2);
995 && (ptrType = fde_pointer_type(cie)) >= 0
996 && read_pointer(&ptr,
997 (const u8 *)(fde + 1) + *fde,
998 ptrType) == startLoc) {
999 if (!(ptrType & DW_EH_PE_indirect))
1001 DW_EH_PE_FORM | DW_EH_PE_signed;
1003 startLoc + read_pointer(&ptr,
1018 memset(&state, 0, sizeof(state));
1019 state.cieEnd = ptr; /* keep here temporarily */
1020 ptr = (const u8 *)(cie + 2);
1021 end = (const u8 *)(cie + 1) + *cie;
1022 frame->call_frame = 1;
1024 /* check if augmentation size is first (thus present) */
1026 while (++ptr < end && *ptr) {
1028 /* chk for ignorable or already handled
1029 * nul-terminated augmentation string */
1035 frame->call_frame = 0;
1043 if (ptr >= end || *ptr)
1049 /* get code alignment factor */
1050 state.codeAlign = get_uleb128(&ptr, end);
1051 /* get data alignment factor */
1052 state.dataAlign = get_sleb128(&ptr, end);
1053 if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end)
1057 state.version <= 1 ? *ptr++ : get_uleb128(&ptr,
1059 unw_debug("CIE Frame Info:\n");
1060 unw_debug("return Address register 0x%lx\n",
1062 unw_debug("data Align: %ld\n", state.dataAlign);
1063 unw_debug("code Align: %lu\n", state.codeAlign);
1064 /* skip augmentation */
1065 if (((const char *)(cie + 2))[1] == 'z') {
1066 uleb128_t augSize = get_uleb128(&ptr, end);
1070 if (ptr > end || retAddrReg >= ARRAY_SIZE(reg_info)
1071 || REG_INVALID(retAddrReg)
1072 || reg_info[retAddrReg].width !=
1073 sizeof(unsigned long))
1078 state.cieStart = ptr;
1081 end = (const u8 *)(fde + 1) + *fde;
1082 /* skip augmentation */
1083 if (((const char *)(cie + 2))[1] == 'z') {
1084 uleb128_t augSize = get_uleb128(&ptr, end);
1086 if ((ptr += augSize) > end)
1090 if (cie == NULL || fde == NULL) {
1091 #ifdef CONFIG_FRAME_POINTER
1092 unsigned long top, bottom;
1094 top = STACK_TOP_UNW(frame->task);
1095 bottom = STACK_BOTTOM_UNW(frame->task);
1096 #if FRAME_RETADDR_OFFSET < 0
1097 if (UNW_SP(frame) < top && UNW_FP(frame) <= UNW_SP(frame)
1098 && bottom < UNW_FP(frame)
1100 if (UNW_SP(frame) > top && UNW_FP(frame) >= UNW_SP(frame)
1101 && bottom > UNW_FP(frame)
1103 && !((UNW_SP(frame) | UNW_FP(frame))
1104 & (sizeof(unsigned long) - 1))) {
1107 if (!__get_user(link, (unsigned long *)
1108 (UNW_FP(frame) + FRAME_LINK_OFFSET))
1109 #if FRAME_RETADDR_OFFSET < 0
1110 && link > bottom && link < UNW_FP(frame)
1112 && link > UNW_FP(frame) && link < bottom
1114 && !(link & (sizeof(link) - 1))
1115 && !__get_user(UNW_PC(frame),
1116 (unsigned long *)(UNW_FP(frame)
1117 + FRAME_RETADDR_OFFSET)))
1120 UNW_FP(frame) + FRAME_RETADDR_OFFSET
1121 #if FRAME_RETADDR_OFFSET < 0
1126 sizeof(UNW_PC(frame));
1127 UNW_FP(frame) = link;
1134 state.org = startLoc;
1135 memcpy(&state.cfa, &badCFA, sizeof(state.cfa));
1137 unw_debug("\nProcess instructions\n");
1139 /* process instructions
1140 * For ARC, we optimize by having blink(retAddrReg) with
1141 * the sameValue in the leaf function, so we should not check
1142 * state.regs[retAddrReg].where == Nowhere
1144 if (!processCFI(ptr, end, pc, ptrType, &state)
1145 || state.loc > endLoc
1146 /* || state.regs[retAddrReg].where == Nowhere */
1147 || state.cfa.reg >= ARRAY_SIZE(reg_info)
1148 || reg_info[state.cfa.reg].width != sizeof(unsigned long)
1149 || state.cfa.offs % sizeof(unsigned long))
1155 unw_debug("\nRegister State Based on the rules parsed from FDE:\n");
1156 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1161 switch (state.regs[i].where) {
1165 unw_debug(" r%d: c(%lu),", i, state.regs[i].value);
1168 unw_debug(" r%d: r(%lu),", i, state.regs[i].value);
1171 unw_debug(" r%d: v(%lu),", i, state.regs[i].value);
1180 #ifndef CONFIG_AS_CFI_SIGNAL_FRAME
1181 if (frame->call_frame
1182 && !UNW_DEFAULT_RA(state.regs[retAddrReg], state.dataAlign))
1183 frame->call_frame = 0;
1185 cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs;
1186 startLoc = min_t(unsigned long, UNW_SP(frame), cfa);
1187 endLoc = max_t(unsigned long, UNW_SP(frame), cfa);
1188 if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
1189 startLoc = min(STACK_LIMIT(cfa), cfa);
1190 endLoc = max(STACK_LIMIT(cfa), cfa);
1193 unw_debug("\nCFA reg: 0x%lx, offset: 0x%lx => 0x%lx\n",
1194 state.cfa.reg, state.cfa.offs, cfa);
1196 for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1197 if (REG_INVALID(i)) {
1198 if (state.regs[i].where == Nowhere)
1202 switch (state.regs[i].where) {
1206 if (state.regs[i].value >= ARRAY_SIZE(reg_info)
1207 || REG_INVALID(state.regs[i].value)
1208 || reg_info[i].width >
1209 reg_info[state.regs[i].value].width)
1211 switch (reg_info[state.regs[i].value].width) {
1213 state.regs[i].value =
1214 FRAME_REG(state.regs[i].value, const u8);
1217 state.regs[i].value =
1218 FRAME_REG(state.regs[i].value, const u16);
1221 state.regs[i].value =
1222 FRAME_REG(state.regs[i].value, const u32);
1226 state.regs[i].value =
1227 FRAME_REG(state.regs[i].value, const u64);
1237 unw_debug("\nRegister state after evaluation with realtime Stack:\n");
1238 fptr = (unsigned long *)(&frame->regs);
1239 for (i = 0; i < ARRAY_SIZE(state.regs); ++i, fptr++) {
1243 switch (state.regs[i].where) {
1245 if (reg_info[i].width != sizeof(UNW_SP(frame))
1246 || &FRAME_REG(i, __typeof__(UNW_SP(frame)))
1249 UNW_SP(frame) = cfa;
1252 switch (reg_info[i].width) {
1254 FRAME_REG(i, u8) = state.regs[i].value;
1257 FRAME_REG(i, u16) = state.regs[i].value;
1260 FRAME_REG(i, u32) = state.regs[i].value;
1264 FRAME_REG(i, u64) = state.regs[i].value;
1272 if (reg_info[i].width != sizeof(unsigned long))
1274 FRAME_REG(i, unsigned long) = cfa + state.regs[i].value
1278 addr = cfa + state.regs[i].value * state.dataAlign;
1280 if ((state.regs[i].value * state.dataAlign)
1281 % sizeof(unsigned long)
1283 || addr + sizeof(unsigned long) < addr
1284 || addr + sizeof(unsigned long) > endLoc)
1287 switch (reg_info[i].width) {
1289 __get_user(FRAME_REG(i, u8),
1293 __get_user(FRAME_REG(i, u16),
1294 (u16 __user *)addr);
1297 __get_user(FRAME_REG(i, u32),
1298 (u32 __user *)addr);
1302 __get_user(FRAME_REG(i, u64),
1303 (u64 __user *)addr);
1312 unw_debug("r%d: 0x%lx ", i, *fptr);
1318 EXPORT_SYMBOL(arc_unwind);