arch/arc/kernel/unwind.c

   1 /*
   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>
   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 version 2 as
   8  * published by the Free Software Foundation.
   9  *
  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.
  14  */
  15
  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>
  27
  28 extern char __start_unwind[], __end_unwind[];
  29 /* extern const u8 __start_unwind_hdr[], __end_unwind_hdr[];*/
  30
  31 /* #define UNWIND_DEBUG */
  32
  33 #ifdef UNWIND_DEBUG
  34 int dbg_unw;
  35 #define unw_debug(fmt, ...)                     \
  36 do {                                            \
  37         if (dbg_unw)                            \
  38                 pr_info(fmt, ##__VA_ARGS__);    \
  39 } while (0);
  40 #else
  41 #define unw_debug(fmt, ...)
  42 #endif
  43
  44 #define MAX_STACK_DEPTH 8
  45
  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) \
  52         }
  53 #define PTREGS_INFO(f) EXTRA_INFO(regs.f)
  54
  55 static const struct {
  56         unsigned offs:BITS_PER_LONG / 2;
  57         unsigned width:BITS_PER_LONG / 2;
  58 } reg_info[] = {
  59 UNW_REGISTER_INFO};
  60
  61 #undef PTREGS_INFO
  62 #undef EXTRA_INFO
  63
  64 #ifndef REG_INVALID
  65 #define REG_INVALID(r) (reg_info[r].width == 0)
  66 #endif
  67
  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
  96
  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
 113
 114 typedef unsigned long uleb128_t;
 115 typedef signed long sleb128_t;
 116
 117 static struct unwind_table {
 118         struct {
 119                 unsigned long pc;
 120                 unsigned long range;
 121         } core, init;
 122         const void *address;
 123         unsigned long size;
 124         const unsigned char *header;
 125         unsigned long hdrsz;
 126         struct unwind_table *link;
 127         const char *name;
 128 } root_table;
 129
 130 struct unwind_item {
 131         enum item_location {
 132                 Nowhere,
 133                 Memory,
 134                 Register,
 135                 Value
 136         } where;
 137         uleb128_t value;
 138 };
 139
 140 struct unwind_state {
 141         uleb128_t loc, org;
 142         const u8 *cieStart, *cieEnd;
 143         uleb128_t codeAlign;
 144         sleb128_t dataAlign;
 145         struct cfa {
 146                 uleb128_t reg, offs;
 147         } cfa;
 148         struct unwind_item regs[ARRAY_SIZE(reg_info)];
 149         unsigned stackDepth:8;
 150         unsigned version:8;
 151         const u8 *label;
 152         const u8 *stack[MAX_STACK_DEPTH];
 153 };
 154
 155 static const struct cfa badCFA = { ARRAY_SIZE(reg_info), 1 };
 156
 157 static struct unwind_table *find_table(unsigned long pc)
 158 {
 159         struct unwind_table *table;
 160
 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))
 166                         break;
 167
 168         return table;
 169 }
 170
 171 static unsigned long read_pointer(const u8 **pLoc,
 172                                   const void *end, signed ptrType);
 173
 174 static void init_unwind_table(struct unwind_table *table, const char *name,
 175                               const void *core_start, unsigned long core_size,
 176                               const void *init_start, unsigned long init_size,
 177                               const void *table_start, unsigned long table_size,
 178                               const u8 *header_start, unsigned long header_size)
 179 {
 180         const u8 *ptr = header_start + 4;
 181         const u8 *end = header_start + header_size;
 182
 183         table->core.pc = (unsigned long)core_start;
 184         table->core.range = core_size;
 185         table->init.pc = (unsigned long)init_start;
 186         table->init.range = init_size;
 187         table->address = table_start;
 188         table->size = table_size;
 189
 190         /* See if the linker provided table looks valid. */
 191         if (header_size <= 4
 192             || header_start[0] != 1
 193             || (void *)read_pointer(&ptr, end, header_start[1]) != table_start
 194             || header_start[2] == DW_EH_PE_omit
 195             || read_pointer(&ptr, end, header_start[2]) <= 0
 196             || header_start[3] == DW_EH_PE_omit)
 197                 header_start = NULL;
 198
 199         table->hdrsz = header_size;
 200         smp_wmb();
 201         table->header = header_start;
 202         table->link = NULL;
 203         table->name = name;
 204 }
 205
 206 void __init arc_unwind_init(void)
 207 {
 208         init_unwind_table(&root_table, "kernel", _text, _end - _text, NULL, 0,
 209                           __start_unwind, __end_unwind - __start_unwind,
 210                           NULL, 0);
 211           /*__start_unwind_hdr, __end_unwind_hdr - __start_unwind_hdr);*/
 212 }
 213
 214 static const u32 bad_cie, not_fde;
 215 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *);
 216 static signed fde_pointer_type(const u32 *cie);
 217
 218 struct eh_frame_hdr_table_entry {
 219         unsigned long start, fde;
 220 };
 221
 222 static int cmp_eh_frame_hdr_table_entries(const void *p1, const void *p2)
 223 {
 224         const struct eh_frame_hdr_table_entry *e1 = p1;
 225         const struct eh_frame_hdr_table_entry *e2 = p2;
 226
 227         return (e1->start > e2->start) - (e1->start < e2->start);
 228 }
 229
 230 static void swap_eh_frame_hdr_table_entries(void *p1, void *p2, int size)
 231 {
 232         struct eh_frame_hdr_table_entry *e1 = p1;
 233         struct eh_frame_hdr_table_entry *e2 = p2;
 234         unsigned long v;
 235
 236         v = e1->start;
 237         e1->start = e2->start;
 238         e2->start = v;
 239         v = e1->fde;
 240         e1->fde = e2->fde;
 241         e2->fde = v;
 242 }
 243
 244 static void __init setup_unwind_table(struct unwind_table *table,
 245                                       void *(*alloc) (unsigned long))
 246 {
 247         const u8 *ptr;
 248         unsigned long tableSize = table->size, hdrSize;
 249         unsigned n;
 250         const u32 *fde;
 251         struct {
 252                 u8 version;
 253                 u8 eh_frame_ptr_enc;
 254                 u8 fde_count_enc;
 255                 u8 table_enc;
 256                 unsigned long eh_frame_ptr;
 257                 unsigned int fde_count;
 258                 struct eh_frame_hdr_table_entry table[];
 259         } __attribute__ ((__packed__)) *header;
 260
 261         if (table->header)
 262                 return;
 263
 264         if (table->hdrsz)
 265                 pr_warn(".eh_frame_hdr for '%s' present but unusable\n",
 266                         table->name);
 267
 268         if (tableSize & (sizeof(*fde) - 1))
 269                 return;
 270
 271         for (fde = table->address, n = 0;
 272              tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde;
 273              tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
 274                 const u32 *cie = cie_for_fde(fde, table);
 275                 signed ptrType;
 276
 277                 if (cie == &not_fde)
 278                         continue;
 279                 if (cie == NULL || cie == &bad_cie)
 280                         return;
 281                 ptrType = fde_pointer_type(cie);
 282                 if (ptrType < 0)
 283                         return;
 284
 285                 ptr = (const u8 *)(fde + 2);
 286                 if (!read_pointer(&ptr, (const u8 *)(fde + 1) + *fde,
 287                                                                 ptrType)) {
 288                         /* FIXME_Rajesh We have 4 instances of null addresses
 289                          * instead of the initial loc addr
 290                          * return;
 291                          */
 292                         WARN(1, "unwinder: FDE->initial_location NULL %p\n",
 293                                 (const u8 *)(fde + 1) + *fde);
 294                 }
 295                 ++n;
 296         }
 297
 298         if (tableSize || !n)
 299                 return;
 300
 301         hdrSize = 4 + sizeof(unsigned long) + sizeof(unsigned int)
 302             + 2 * n * sizeof(unsigned long);
 303         header = alloc(hdrSize);
 304         if (!header)
 305                 return;
 306         header->version = 1;
 307         header->eh_frame_ptr_enc = DW_EH_PE_abs | DW_EH_PE_native;
 308         header->fde_count_enc = DW_EH_PE_abs | DW_EH_PE_data4;
 309         header->table_enc = DW_EH_PE_abs | DW_EH_PE_native;
 310         put_unaligned((unsigned long)table->address, &header->eh_frame_ptr);
 311         BUILD_BUG_ON(offsetof(typeof(*header), fde_count)
 312                      % __alignof(typeof(header->fde_count)));
 313         header->fde_count = n;
 314
 315         BUILD_BUG_ON(offsetof(typeof(*header), table)
 316                      % __alignof(typeof(*header->table)));
 317         for (fde = table->address, tableSize = table->size, n = 0;
 318              tableSize;
 319              tableSize -= sizeof(*fde) + *fde, fde += 1 + *fde / sizeof(*fde)) {
 320                 /* const u32 *cie = fde + 1 - fde[1] / sizeof(*fde); */
 321                 const u32 *cie = (const u32 *)(fde[1]);
 322
 323                 if (fde[1] == 0xffffffff)
 324                         continue;       /* this is a CIE */
 325                 ptr = (const u8 *)(fde + 2);
 326                 header->table[n].start = read_pointer(&ptr,
 327                                                       (const u8 *)(fde + 1) +
 328                                                       *fde,
 329                                                       fde_pointer_type(cie));
 330                 header->table[n].fde = (unsigned long)fde;
 331                 ++n;
 332         }
 333         WARN_ON(n != header->fde_count);
 334
 335         sort(header->table,
 336              n,
 337              sizeof(*header->table),
 338              cmp_eh_frame_hdr_table_entries, swap_eh_frame_hdr_table_entries);
 339
 340         table->hdrsz = hdrSize;
 341         smp_wmb();
 342         table->header = (const void *)header;
 343 }
 344
 345 static void *__init balloc(unsigned long sz)
 346 {
 347         return __alloc_bootmem_nopanic(sz,
 348                                        sizeof(unsigned int),
 349                                        __pa(MAX_DMA_ADDRESS));
 350 }
 351
 352 void __init arc_unwind_setup(void)
 353 {
 354         setup_unwind_table(&root_table, balloc);
 355 }
 356
 357 #ifdef CONFIG_MODULES
 358
 359 static struct unwind_table *last_table;
 360
 361 /* Must be called with module_mutex held. */
 362 void *unwind_add_table(struct module *module, const void *table_start,
 363                        unsigned long table_size)
 364 {
 365         struct unwind_table *table;
 366
 367         if (table_size <= 0)
 368                 return NULL;
 369
 370         table = kmalloc(sizeof(*table), GFP_KERNEL);
 371         if (!table)
 372                 return NULL;
 373
 374         init_unwind_table(table, module->name,
 375                           module->module_core, module->core_size,
 376                           module->module_init, module->init_size,
 377                           table_start, table_size,
 378                           NULL, 0);
 379
 380 #ifdef UNWIND_DEBUG
 381         unw_debug("Table added for [%s] %lx %lx\n",
 382                 module->name, table->core.pc, table->core.range);
 383 #endif
 384         if (last_table)
 385                 last_table->link = table;
 386         else
 387                 root_table.link = table;
 388         last_table = table;
 389
 390         return table;
 391 }
 392
 393 struct unlink_table_info {
 394         struct unwind_table *table;
 395         int init_only;
 396 };
 397
 398 static int unlink_table(void *arg)
 399 {
 400         struct unlink_table_info *info = arg;
 401         struct unwind_table *table = info->table, *prev;
 402
 403         for (prev = &root_table; prev->link && prev->link != table;
 404              prev = prev->link)
 405                 ;
 406
 407         if (prev->link) {
 408                 if (info->init_only) {
 409                         table->init.pc = 0;
 410                         table->init.range = 0;
 411                         info->table = NULL;
 412                 } else {
 413                         prev->link = table->link;
 414                         if (!prev->link)
 415                                 last_table = prev;
 416                 }
 417         } else
 418                 info->table = NULL;
 419
 420         return 0;
 421 }
 422
 423 /* Must be called with module_mutex held. */
 424 void unwind_remove_table(void *handle, int init_only)
 425 {
 426         struct unwind_table *table = handle;
 427         struct unlink_table_info info;
 428
 429         if (!table || table == &root_table)
 430                 return;
 431
 432         if (init_only && table == last_table) {
 433                 table->init.pc = 0;
 434                 table->init.range = 0;
 435                 return;
 436         }
 437
 438         info.table = table;
 439         info.init_only = init_only;
 440
 441         unlink_table(&info); /* XXX: SMP */
 442         kfree(table);
 443 }
 444
 445 #endif /* CONFIG_MODULES */
 446
 447 static uleb128_t get_uleb128(const u8 **pcur, const u8 *end)
 448 {
 449         const u8 *cur = *pcur;
 450         uleb128_t value;
 451         unsigned shift;
 452
 453         for (shift = 0, value = 0; cur < end; shift += 7) {
 454                 if (shift + 7 > 8 * sizeof(value)
 455                     && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
 456                         cur = end + 1;
 457                         break;
 458                 }
 459                 value |= (uleb128_t) (*cur & 0x7f) << shift;
 460                 if (!(*cur++ & 0x80))
 461                         break;
 462         }
 463         *pcur = cur;
 464
 465         return value;
 466 }
 467
 468 static sleb128_t get_sleb128(const u8 **pcur, const u8 *end)
 469 {
 470         const u8 *cur = *pcur;
 471         sleb128_t value;
 472         unsigned shift;
 473
 474         for (shift = 0, value = 0; cur < end; shift += 7) {
 475                 if (shift + 7 > 8 * sizeof(value)
 476                     && (*cur & 0x7fU) >= (1U << (8 * sizeof(value) - shift))) {
 477                         cur = end + 1;
 478                         break;
 479                 }
 480                 value |= (sleb128_t) (*cur & 0x7f) << shift;
 481                 if (!(*cur & 0x80)) {
 482                         value |= -(*cur++ & 0x40) << shift;
 483                         break;
 484                 }
 485         }
 486         *pcur = cur;
 487
 488         return value;
 489 }
 490
 491 static const u32 *cie_for_fde(const u32 *fde, const struct unwind_table *table)
 492 {
 493         const u32 *cie;
 494
 495         if (!*fde || (*fde & (sizeof(*fde) - 1)))
 496                 return &bad_cie;
 497
 498         if (fde[1] == 0xffffffff)
 499                 return &not_fde;        /* this is a CIE */
 500
 501         if ((fde[1] & (sizeof(*fde) - 1)))
 502 /* || fde[1] > (unsigned long)(fde + 1) - (unsigned long)table->address) */
 503                 return NULL;    /* this is not a valid FDE */
 504
 505         /* cie = fde + 1 - fde[1] / sizeof(*fde); */
 506         cie = (u32 *) fde[1];
 507
 508         if (*cie <= sizeof(*cie) + 4 || *cie >= fde[1] - sizeof(*fde)
 509             || (*cie & (sizeof(*cie) - 1))
 510             || (cie[1] != 0xffffffff))
 511                 return NULL;    /* this is not a (valid) CIE */
 512         return cie;
 513 }
 514
 515 static unsigned long read_pointer(const u8 **pLoc, const void *end,
 516                                   signed ptrType)
 517 {
 518         unsigned long value = 0;
 519         union {
 520                 const u8 *p8;
 521                 const u16 *p16u;
 522                 const s16 *p16s;
 523                 const u32 *p32u;
 524                 const s32 *p32s;
 525                 const unsigned long *pul;
 526         } ptr;
 527
 528         if (ptrType < 0 || ptrType == DW_EH_PE_omit)
 529                 return 0;
 530         ptr.p8 = *pLoc;
 531         switch (ptrType & DW_EH_PE_FORM) {
 532         case DW_EH_PE_data2:
 533                 if (end < (const void *)(ptr.p16u + 1))
 534                         return 0;
 535                 if (ptrType & DW_EH_PE_signed)
 536                         value = get_unaligned((u16 *) ptr.p16s++);
 537                 else
 538                         value = get_unaligned((u16 *) ptr.p16u++);
 539                 break;
 540         case DW_EH_PE_data4:
 541 #ifdef CONFIG_64BIT
 542                 if (end < (const void *)(ptr.p32u + 1))
 543                         return 0;
 544                 if (ptrType & DW_EH_PE_signed)
 545                         value = get_unaligned(ptr.p32s++);
 546                 else
 547                         value = get_unaligned(ptr.p32u++);
 548                 break;
 549         case DW_EH_PE_data8:
 550                 BUILD_BUG_ON(sizeof(u64) != sizeof(value));
 551 #else
 552                 BUILD_BUG_ON(sizeof(u32) != sizeof(value));
 553 #endif
 554         case DW_EH_PE_native:
 555                 if (end < (const void *)(ptr.pul + 1))
 556                         return 0;
 557                 value = get_unaligned((unsigned long *)ptr.pul++);
 558                 break;
 559         case DW_EH_PE_leb128:
 560                 BUILD_BUG_ON(sizeof(uleb128_t) > sizeof(value));
 561                 value = ptrType & DW_EH_PE_signed ? get_sleb128(&ptr.p8, end)
 562                     : get_uleb128(&ptr.p8, end);
 563                 if ((const void *)ptr.p8 > end)
 564                         return 0;
 565                 break;
 566         default:
 567                 return 0;
 568         }
 569         switch (ptrType & DW_EH_PE_ADJUST) {
 570         case DW_EH_PE_abs:
 571                 break;
 572         case DW_EH_PE_pcrel:
 573                 value += (unsigned long)*pLoc;
 574                 break;
 575         default:
 576                 return 0;
 577         }
 578         if ((ptrType & DW_EH_PE_indirect)
 579             && __get_user(value, (unsigned long __user *)value))
 580                 return 0;
 581         *pLoc = ptr.p8;
 582
 583         return value;
 584 }
 585
 586 static signed fde_pointer_type(const u32 *cie)
 587 {
 588         const u8 *ptr = (const u8 *)(cie + 2);
 589         unsigned version = *ptr;
 590
 591         if (version != 1)
 592                 return -1;      /* unsupported */
 593
 594         if (*++ptr) {
 595                 const char *aug;
 596                 const u8 *end = (const u8 *)(cie + 1) + *cie;
 597                 uleb128_t len;
 598
 599                 /* check if augmentation size is first (and thus present) */
 600                 if (*ptr != 'z')
 601                         return -1;
 602
 603                 /* check if augmentation string is nul-terminated */
 604                 aug = (const void *)ptr;
 605                 ptr = memchr(aug, 0, end - ptr);
 606                 if (ptr == NULL)
 607                         return -1;
 608
 609                 ++ptr;          /* skip terminator */
 610                 get_uleb128(&ptr, end); /* skip code alignment */
 611                 get_sleb128(&ptr, end); /* skip data alignment */
 612                 /* skip return address column */
 613                 version <= 1 ? (void) ++ptr : (void)get_uleb128(&ptr, end);
 614                 len = get_uleb128(&ptr, end);   /* augmentation length */
 615
 616                 if (ptr + len < ptr || ptr + len > end)
 617                         return -1;
 618
 619                 end = ptr + len;
 620                 while (*++aug) {
 621                         if (ptr >= end)
 622                                 return -1;
 623                         switch (*aug) {
 624                         case 'L':
 625                                 ++ptr;
 626                                 break;
 627                         case 'P':{
 628                                         signed ptrType = *ptr++;
 629
 630                                         if (!read_pointer(&ptr, end, ptrType)
 631                                             || ptr > end)
 632                                                 return -1;
 633                                 }
 634                                 break;
 635                         case 'R':
 636                                 return *ptr;
 637                         default:
 638                                 return -1;
 639                         }
 640                 }
 641         }
 642         return DW_EH_PE_native | DW_EH_PE_abs;
 643 }
 644
 645 static int advance_loc(unsigned long delta, struct unwind_state *state)
 646 {
 647         state->loc += delta * state->codeAlign;
 648
 649         /* FIXME_Rajesh: Probably we are defining for the initial range as well;
 650            return delta > 0;
 651          */
 652         unw_debug("delta %3lu => loc 0x%lx: ", delta, state->loc);
 653         return 1;
 654 }
 655
 656 static void set_rule(uleb128_t reg, enum item_location where, uleb128_t value,
 657                      struct unwind_state *state)
 658 {
 659         if (reg < ARRAY_SIZE(state->regs)) {
 660                 state->regs[reg].where = where;
 661                 state->regs[reg].value = value;
 662
 663 #ifdef UNWIND_DEBUG
 664                 unw_debug("r%lu: ", reg);
 665                 switch (where) {
 666                 case Nowhere:
 667                         unw_debug("s ");
 668                         break;
 669                 case Memory:
 670                         unw_debug("c(%lu) ", value);
 671                         break;
 672                 case Register:
 673                         unw_debug("r(%lu) ", value);
 674                         break;
 675                 case Value:
 676                         unw_debug("v(%lu) ", value);
 677                         break;
 678                 default:
 679                         break;
 680                 }
 681 #endif
 682         }
 683 }
 684
 685 static int processCFI(const u8 *start, const u8 *end, unsigned long targetLoc,
 686                       signed ptrType, struct unwind_state *state)
 687 {
 688         union {
 689                 const u8 *p8;
 690                 const u16 *p16;
 691                 const u32 *p32;
 692         } ptr;
 693         int result = 1;
 694         u8 opcode;
 695
 696         if (start != state->cieStart) {
 697                 state->loc = state->org;
 698                 result =
 699                     processCFI(state->cieStart, state->cieEnd, 0, ptrType,
 700                                state);
 701                 if (targetLoc == 0 && state->label == NULL)
 702                         return result;
 703         }
 704         for (ptr.p8 = start; result && ptr.p8 < end;) {
 705                 switch (*ptr.p8 >> 6) {
 706                         uleb128_t value;
 707
 708                 case 0:
 709                         opcode = *ptr.p8++;
 710
 711                         switch (opcode) {
 712                         case DW_CFA_nop:
 713                                 unw_debug("cfa nop ");
 714                                 break;
 715                         case DW_CFA_set_loc:
 716                                 state->loc = read_pointer(&ptr.p8, end,
 717                                                           ptrType);
 718                                 if (state->loc == 0)
 719                                         result = 0;
 720                                 unw_debug("cfa_set_loc: 0x%lx ", state->loc);
 721                                 break;
 722                         case DW_CFA_advance_loc1:
 723                                 unw_debug("\ncfa advance loc1:");
 724                                 result = ptr.p8 < end
 725                                     && advance_loc(*ptr.p8++, state);
 726                                 break;
 727                         case DW_CFA_advance_loc2:
 728                                 value = *ptr.p8++;
 729                                 value += *ptr.p8++ << 8;
 730                                 unw_debug("\ncfa advance loc2:");
 731                                 result = ptr.p8 <= end + 2
 732                                     /* && advance_loc(*ptr.p16++, state); */
 733                                     && advance_loc(value, state);
 734                                 break;
 735                         case DW_CFA_advance_loc4:
 736                                 unw_debug("\ncfa advance loc4:");
 737                                 result = ptr.p8 <= end + 4
 738                                     && advance_loc(*ptr.p32++, state);
 739                                 break;
 740                         case DW_CFA_offset_extended:
 741                                 value = get_uleb128(&ptr.p8, end);
 742                                 unw_debug("cfa_offset_extended: ");
 743                                 set_rule(value, Memory,
 744                                          get_uleb128(&ptr.p8, end), state);
 745                                 break;
 746                         case DW_CFA_val_offset:
 747                                 value = get_uleb128(&ptr.p8, end);
 748                                 set_rule(value, Value,
 749                                          get_uleb128(&ptr.p8, end), state);
 750                                 break;
 751                         case DW_CFA_offset_extended_sf:
 752                                 value = get_uleb128(&ptr.p8, end);
 753                                 set_rule(value, Memory,
 754                                          get_sleb128(&ptr.p8, end), state);
 755                                 break;
 756                         case DW_CFA_val_offset_sf:
 757                                 value = get_uleb128(&ptr.p8, end);
 758                                 set_rule(value, Value,
 759                                          get_sleb128(&ptr.p8, end), state);
 760                                 break;
 761                         case DW_CFA_restore_extended:
 762                                 unw_debug("cfa_restore_extended: ");
 763                         case DW_CFA_undefined:
 764                                 unw_debug("cfa_undefined: ");
 765                         case DW_CFA_same_value:
 766                                 unw_debug("cfa_same_value: ");
 767                                 set_rule(get_uleb128(&ptr.p8, end), Nowhere, 0,
 768                                          state);
 769                                 break;
 770                         case DW_CFA_register:
 771                                 unw_debug("cfa_register: ");
 772                                 value = get_uleb128(&ptr.p8, end);
 773                                 set_rule(value,
 774                                          Register,
 775                                          get_uleb128(&ptr.p8, end), state);
 776                                 break;
 777                         case DW_CFA_remember_state:
 778                                 unw_debug("cfa_remember_state: ");
 779                                 if (ptr.p8 == state->label) {
 780                                         state->label = NULL;
 781                                         return 1;
 782                                 }
 783                                 if (state->stackDepth >= MAX_STACK_DEPTH)
 784                                         return 0;
 785                                 state->stack[state->stackDepth++] = ptr.p8;
 786                                 break;
 787                         case DW_CFA_restore_state:
 788                                 unw_debug("cfa_restore_state: ");
 789                                 if (state->stackDepth) {
 790                                         const uleb128_t loc = state->loc;
 791                                         const u8 *label = state->label;
 792
 793                                         state->label =
 794                                             state->stack[state->stackDepth - 1];
 795                                         memcpy(&state->cfa, &badCFA,
 796                                                sizeof(state->cfa));
 797                                         memset(state->regs, 0,
 798                                                sizeof(state->regs));
 799                                         state->stackDepth = 0;
 800                                         result =
 801                                             processCFI(start, end, 0, ptrType,
 802                                                        state);
 803                                         state->loc = loc;
 804                                         state->label = label;
 805                                 } else
 806                                         return 0;
 807                                 break;
 808                         case DW_CFA_def_cfa:
 809                                 state->cfa.reg = get_uleb128(&ptr.p8, end);
 810                                 unw_debug("cfa_def_cfa: r%lu ", state->cfa.reg);
 811                                 /*nobreak*/
 812                         case DW_CFA_def_cfa_offset:
 813                                 state->cfa.offs = get_uleb128(&ptr.p8, end);
 814                                 unw_debug("cfa_def_cfa_offset: 0x%lx ",
 815                                           state->cfa.offs);
 816                                 break;
 817                         case DW_CFA_def_cfa_sf:
 818                                 state->cfa.reg = get_uleb128(&ptr.p8, end);
 819                                 /*nobreak */
 820                         case DW_CFA_def_cfa_offset_sf:
 821                                 state->cfa.offs = get_sleb128(&ptr.p8, end)
 822                                     * state->dataAlign;
 823                                 break;
 824                         case DW_CFA_def_cfa_register:
 825                                 unw_debug("cfa_def_cfa_regsiter: ");
 826                                 state->cfa.reg = get_uleb128(&ptr.p8, end);
 827                                 break;
 828                                 /*todo case DW_CFA_def_cfa_expression: */
 829                                 /*todo case DW_CFA_expression: */
 830                                 /*todo case DW_CFA_val_expression: */
 831                         case DW_CFA_GNU_args_size:
 832                                 get_uleb128(&ptr.p8, end);
 833                                 break;
 834                         case DW_CFA_GNU_negative_offset_extended:
 835                                 value = get_uleb128(&ptr.p8, end);
 836                                 set_rule(value,
 837                                          Memory,
 838                                          (uleb128_t) 0 - get_uleb128(&ptr.p8,
 839                                                                      end),
 840                                          state);
 841                                 break;
 842                         case DW_CFA_GNU_window_save:
 843                         default:
 844                                 unw_debug("UNKNOWN OPCODE 0x%x\n", opcode);
 845                                 result = 0;
 846                                 break;
 847                         }
 848                         break;
 849                 case 1:
 850                         unw_debug("\ncfa_adv_loc: ");
 851                         result = advance_loc(*ptr.p8++ & 0x3f, state);
 852                         break;
 853                 case 2:
 854                         unw_debug("cfa_offset: ");
 855                         value = *ptr.p8++ & 0x3f;
 856                         set_rule(value, Memory, get_uleb128(&ptr.p8, end),
 857                                  state);
 858                         break;
 859                 case 3:
 860                         unw_debug("cfa_restore: ");
 861                         set_rule(*ptr.p8++ & 0x3f, Nowhere, 0, state);
 862                         break;
 863                 }
 864
 865                 if (ptr.p8 > end)
 866                         result = 0;
 867                 if (result && targetLoc != 0 && targetLoc < state->loc)
 868                         return 1;
 869         }
 870
 871         return result && ptr.p8 == end && (targetLoc == 0 || (
 872                 /*todo While in theory this should apply, gcc in practice omits
 873                   everything past the function prolog, and hence the location
 874                   never reaches the end of the function.
 875                 targetLoc < state->loc && */  state->label == NULL));
 876 }
 877
 878 /* Unwind to previous to frame.  Returns 0 if successful, negative
 879  * number in case of an error. */
 880 int arc_unwind(struct unwind_frame_info *frame)
 881 {
 882 #define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
 883         const u32 *fde = NULL, *cie = NULL;
 884         const u8 *ptr = NULL, *end = NULL;
 885         unsigned long pc = UNW_PC(frame) - frame->call_frame;
 886         unsigned long startLoc = 0, endLoc = 0, cfa;
 887         unsigned i;
 888         signed ptrType = -1;
 889         uleb128_t retAddrReg = 0;
 890         const struct unwind_table *table;
 891         struct unwind_state state;
 892         unsigned long *fptr;
 893         unsigned long addr;
 894
 895         unw_debug("\n\nUNWIND FRAME:\n");
 896         unw_debug("PC: 0x%lx BLINK: 0x%lx, SP: 0x%lx, FP: 0x%x\n",
 897                   UNW_PC(frame), UNW_BLINK(frame), UNW_SP(frame),
 898                   UNW_FP(frame));
 899
 900         if (UNW_PC(frame) == 0)
 901                 return -EINVAL;
 902
 903 #ifdef UNWIND_DEBUG
 904         {
 905                 unsigned long *sptr = (unsigned long *)UNW_SP(frame);
 906                 unw_debug("\nStack Dump:\n");
 907                 for (i = 0; i < 20; i++, sptr++)
 908                         unw_debug("0x%p:  0x%lx\n", sptr, *sptr);
 909                 unw_debug("\n");
 910         }
 911 #endif
 912
 913         table = find_table(pc);
 914         if (table != NULL
 915             && !(table->size & (sizeof(*fde) - 1))) {
 916                 const u8 *hdr = table->header;
 917                 unsigned long tableSize;
 918
 919                 smp_rmb();
 920                 if (hdr && hdr[0] == 1) {
 921                         switch (hdr[3] & DW_EH_PE_FORM) {
 922                         case DW_EH_PE_native:
 923                                 tableSize = sizeof(unsigned long);
 924                                 break;
 925                         case DW_EH_PE_data2:
 926                                 tableSize = 2;
 927                                 break;
 928                         case DW_EH_PE_data4:
 929                                 tableSize = 4;
 930                                 break;
 931                         case DW_EH_PE_data8:
 932                                 tableSize = 8;
 933                                 break;
 934                         default:
 935                                 tableSize = 0;
 936                                 break;
 937                         }
 938                         ptr = hdr + 4;
 939                         end = hdr + table->hdrsz;
 940                         if (tableSize && read_pointer(&ptr, end, hdr[1])
 941                             == (unsigned long)table->address
 942                             && (i = read_pointer(&ptr, end, hdr[2])) > 0
 943                             && i == (end - ptr) / (2 * tableSize)
 944                             && !((end - ptr) % (2 * tableSize))) {
 945                                 do {
 946                                         const u8 *cur =
 947                                             ptr + (i / 2) * (2 * tableSize);
 948
 949                                         startLoc = read_pointer(&cur,
 950                                                                 cur + tableSize,
 951                                                                 hdr[3]);
 952                                         if (pc < startLoc)
 953                                                 i /= 2;
 954                                         else {
 955                                                 ptr = cur - tableSize;
 956                                                 i = (i + 1) / 2;
 957                                         }
 958                                 } while (startLoc && i > 1);
 959                                 if (i == 1
 960                                     && (startLoc = read_pointer(&ptr,
 961                                                                 ptr + tableSize,
 962                                                                 hdr[3])) != 0
 963                                     && pc >= startLoc)
 964                                         fde = (void *)read_pointer(&ptr,
 965                                                                    ptr +
 966                                                                    tableSize,
 967                                                                    hdr[3]);
 968                         }
 969                 }
 970
 971                 if (fde != NULL) {
 972                         cie = cie_for_fde(fde, table);
 973                         ptr = (const u8 *)(fde + 2);
 974                         if (cie != NULL
 975                             && cie != &bad_cie
 976                             && cie != &not_fde
 977                             && (ptrType = fde_pointer_type(cie)) >= 0
 978                             && read_pointer(&ptr,
 979                                             (const u8 *)(fde + 1) + *fde,
 980                                             ptrType) == startLoc) {
 981                                 if (!(ptrType & DW_EH_PE_indirect))
 982                                         ptrType &=
 983                                             DW_EH_PE_FORM | DW_EH_PE_signed;
 984                                 endLoc =
 985                                     startLoc + read_pointer(&ptr,
 986                                                             (const u8 *)(fde +
 987                                                                          1) +
 988                                                             *fde, ptrType);
 989                                 if (pc >= endLoc)
 990                                         fde = NULL;
 991                         } else
 992                                 fde = NULL;
 993                 }
 994                 if (fde == NULL) {
 995                         for (fde = table->address, tableSize = table->size;
 996                              cie = NULL, tableSize > sizeof(*fde)
 997                              && tableSize - sizeof(*fde) >= *fde;
 998                              tableSize -= sizeof(*fde) + *fde,
 999                              fde += 1 + *fde / sizeof(*fde)) {
1000                                 cie = cie_for_fde(fde, table);
1001                                 if (cie == &bad_cie) {
1002                                         cie = NULL;
1003                                         break;
1004                                 }
1005                                 if (cie == NULL
1006                                     || cie == &not_fde
1007                                     || (ptrType = fde_pointer_type(cie)) < 0)
1008                                         continue;
1009                                 ptr = (const u8 *)(fde + 2);
1010                                 startLoc = read_pointer(&ptr,
1011                                                         (const u8 *)(fde + 1) +
1012                                                         *fde, ptrType);
1013                                 if (!startLoc)
1014                                         continue;
1015                                 if (!(ptrType & DW_EH_PE_indirect))
1016                                         ptrType &=
1017                                             DW_EH_PE_FORM | DW_EH_PE_signed;
1018                                 endLoc =
1019                                     startLoc + read_pointer(&ptr,
1020                                                             (const u8 *)(fde +
1021                                                                          1) +
1022                                                             *fde, ptrType);
1023                                 if (pc >= startLoc && pc < endLoc)
1024                                         break;
1025                         }
1026                 }
1027         }
1028         if (cie != NULL) {
1029                 memset(&state, 0, sizeof(state));
1030                 state.cieEnd = ptr;     /* keep here temporarily */
1031                 ptr = (const u8 *)(cie + 2);
1032                 end = (const u8 *)(cie + 1) + *cie;
1033                 frame->call_frame = 1;
1034                 if ((state.version = *ptr) != 1)
1035                         cie = NULL;     /* unsupported version */
1036                 else if (*++ptr) {
1037                         /* check if augmentation size is first (thus present) */
1038                         if (*ptr == 'z') {
1039                                 while (++ptr < end && *ptr) {
1040                                         switch (*ptr) {
1041                                         /* chk for ignorable or already handled
1042                                          * nul-terminated augmentation string */
1043                                         case 'L':
1044                                         case 'P':
1045                                         case 'R':
1046                                                 continue;
1047                                         case 'S':
1048                                                 frame->call_frame = 0;
1049                                                 continue;
1050                                         default:
1051                                                 break;
1052                                         }
1053                                         break;
1054                                 }
1055                         }
1056                         if (ptr >= end || *ptr)
1057                                 cie = NULL;
1058                 }
1059                 ++ptr;
1060         }
1061         if (cie != NULL) {
1062                 /* get code aligment factor */
1063                 state.codeAlign = get_uleb128(&ptr, end);
1064                 /* get data aligment factor */
1065                 state.dataAlign = get_sleb128(&ptr, end);
1066                 if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end)
1067                         cie = NULL;
1068                 else {
1069                         retAddrReg =
1070                             state.version <= 1 ? *ptr++ : get_uleb128(&ptr,
1071                                                                       end);
1072                         unw_debug("CIE Frame Info:\n");
1073                         unw_debug("return Address register 0x%lx\n",
1074                                   retAddrReg);
1075                         unw_debug("data Align: %ld\n", state.dataAlign);
1076                         unw_debug("code Align: %lu\n", state.codeAlign);
1077                         /* skip augmentation */
1078                         if (((const char *)(cie + 2))[1] == 'z') {
1079                                 uleb128_t augSize = get_uleb128(&ptr, end);
1080
1081                                 ptr += augSize;
1082                         }
1083                         if (ptr > end || retAddrReg >= ARRAY_SIZE(reg_info)
1084                             || REG_INVALID(retAddrReg)
1085                             || reg_info[retAddrReg].width !=
1086                             sizeof(unsigned long))
1087                                 cie = NULL;
1088                 }
1089         }
1090         if (cie != NULL) {
1091                 state.cieStart = ptr;
1092                 ptr = state.cieEnd;
1093                 state.cieEnd = end;
1094                 end = (const u8 *)(fde + 1) + *fde;
1095                 /* skip augmentation */
1096                 if (((const char *)(cie + 2))[1] == 'z') {
1097                         uleb128_t augSize = get_uleb128(&ptr, end);
1098
1099                         if ((ptr += augSize) > end)
1100                                 fde = NULL;
1101                 }
1102         }
1103         if (cie == NULL || fde == NULL) {
1104 #ifdef CONFIG_FRAME_POINTER
1105                 unsigned long top, bottom;
1106
1107                 top = STACK_TOP_UNW(frame->task);
1108                 bottom = STACK_BOTTOM_UNW(frame->task);
1109 #if FRAME_RETADDR_OFFSET < 0
1110                 if (UNW_SP(frame) < top && UNW_FP(frame) <= UNW_SP(frame)
1111                     && bottom < UNW_FP(frame)
1112 #else
1113                 if (UNW_SP(frame) > top && UNW_FP(frame) >= UNW_SP(frame)
1114                     && bottom > UNW_FP(frame)
1115 #endif
1116                     && !((UNW_SP(frame) | UNW_FP(frame))
1117                          & (sizeof(unsigned long) - 1))) {
1118                         unsigned long link;
1119
1120                         if (!__get_user(link, (unsigned long *)
1121                                         (UNW_FP(frame) + FRAME_LINK_OFFSET))
1122 #if FRAME_RETADDR_OFFSET < 0
1123                             && link > bottom && link < UNW_FP(frame)
1124 #else
1125                             && link > UNW_FP(frame) && link < bottom
1126 #endif
1127                             && !(link & (sizeof(link) - 1))
1128                             && !__get_user(UNW_PC(frame),
1129                                            (unsigned long *)(UNW_FP(frame)
1130                                                 + FRAME_RETADDR_OFFSET)))
1131                         {
1132                                 UNW_SP(frame) =
1133                                     UNW_FP(frame) + FRAME_RETADDR_OFFSET
1134 #if FRAME_RETADDR_OFFSET < 0
1135                                     -
1136 #else
1137                                     +
1138 #endif
1139                                     sizeof(UNW_PC(frame));
1140                                 UNW_FP(frame) = link;
1141                                 return 0;
1142                         }
1143                 }
1144 #endif
1145                 return -ENXIO;
1146         }
1147         state.org = startLoc;
1148         memcpy(&state.cfa, &badCFA, sizeof(state.cfa));
1149
1150         unw_debug("\nProcess instructions\n");
1151
1152         /* process instructions
1153          * For ARC, we optimize by having blink(retAddrReg) with
1154          * the sameValue in the leaf function, so we should not check
1155          * state.regs[retAddrReg].where == Nowhere
1156          */
1157         if (!processCFI(ptr, end, pc, ptrType, &state)
1158             || state.loc > endLoc
1159 /*         || state.regs[retAddrReg].where == Nowhere */
1160             || state.cfa.reg >= ARRAY_SIZE(reg_info)
1161             || reg_info[state.cfa.reg].width != sizeof(unsigned long)
1162             || state.cfa.offs % sizeof(unsigned long))
1163                 return -EIO;
1164
1165 #ifdef UNWIND_DEBUG
1166         unw_debug("\n");
1167
1168         unw_debug("\nRegister State Based on the rules parsed from FDE:\n");
1169         for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1170
1171                 if (REG_INVALID(i))
1172                         continue;
1173
1174                 switch (state.regs[i].where) {
1175                 case Nowhere:
1176                         break;
1177                 case Memory:
1178                         unw_debug(" r%d: c(%lu),", i, state.regs[i].value);
1179                         break;
1180                 case Register:
1181                         unw_debug(" r%d: r(%lu),", i, state.regs[i].value);
1182                         break;
1183                 case Value:
1184                         unw_debug(" r%d: v(%lu),", i, state.regs[i].value);
1185                         break;
1186                 }
1187         }
1188
1189         unw_debug("\n");
1190 #endif
1191
1192         /* update frame */
1193 #ifndef CONFIG_AS_CFI_SIGNAL_FRAME
1194         if (frame->call_frame
1195             && !UNW_DEFAULT_RA(state.regs[retAddrReg], state.dataAlign))
1196                 frame->call_frame = 0;
1197 #endif
1198         cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs;
1199         startLoc = min_t(unsigned long, UNW_SP(frame), cfa);
1200         endLoc = max_t(unsigned long, UNW_SP(frame), cfa);
1201         if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
1202                 startLoc = min(STACK_LIMIT(cfa), cfa);
1203                 endLoc = max(STACK_LIMIT(cfa), cfa);
1204         }
1205
1206         unw_debug("\nCFA reg: 0x%lx, offset: 0x%lx =>  0x%lx\n",
1207                   state.cfa.reg, state.cfa.offs, cfa);
1208
1209         for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
1210                 if (REG_INVALID(i)) {
1211                         if (state.regs[i].where == Nowhere)
1212                                 continue;
1213                         return -EIO;
1214                 }
1215                 switch (state.regs[i].where) {
1216                 default:
1217                         break;
1218                 case Register:
1219                         if (state.regs[i].value >= ARRAY_SIZE(reg_info)
1220                             || REG_INVALID(state.regs[i].value)
1221                             || reg_info[i].width >
1222                             reg_info[state.regs[i].value].width)
1223                                 return -EIO;
1224                         switch (reg_info[state.regs[i].value].width) {
1225                         case sizeof(u8):
1226                                 state.regs[i].value =
1227                                 FRAME_REG(state.regs[i].value, const u8);
1228                                 break;
1229                         case sizeof(u16):
1230                                 state.regs[i].value =
1231                                 FRAME_REG(state.regs[i].value, const u16);
1232                                 break;
1233                         case sizeof(u32):
1234                                 state.regs[i].value =
1235                                 FRAME_REG(state.regs[i].value, const u32);
1236                                 break;
1237 #ifdef CONFIG_64BIT
1238                         case sizeof(u64):
1239                                 state.regs[i].value =
1240                                 FRAME_REG(state.regs[i].value, const u64);
1241                                 break;
1242 #endif
1243                         default:
1244                                 return -EIO;
1245                         }
1246                         break;
1247                 }
1248         }
1249
1250         unw_debug("\nRegister state after evaluation with realtime Stack:\n");
1251         fptr = (unsigned long *)(&frame->regs);
1252         for (i = 0; i < ARRAY_SIZE(state.regs); ++i, fptr++) {
1253
1254                 if (REG_INVALID(i))
1255                         continue;
1256                 switch (state.regs[i].where) {
1257                 case Nowhere:
1258                         if (reg_info[i].width != sizeof(UNW_SP(frame))
1259                             || &FRAME_REG(i, __typeof__(UNW_SP(frame)))
1260                             != &UNW_SP(frame))
1261                                 continue;
1262                         UNW_SP(frame) = cfa;
1263                         break;
1264                 case Register:
1265                         switch (reg_info[i].width) {
1266                         case sizeof(u8):
1267                                 FRAME_REG(i, u8) = state.regs[i].value;
1268                                 break;
1269                         case sizeof(u16):
1270                                 FRAME_REG(i, u16) = state.regs[i].value;
1271                                 break;
1272                         case sizeof(u32):
1273                                 FRAME_REG(i, u32) = state.regs[i].value;
1274                                 break;
1275 #ifdef CONFIG_64BIT
1276                         case sizeof(u64):
1277                                 FRAME_REG(i, u64) = state.regs[i].value;
1278                                 break;
1279 #endif
1280                         default:
1281                                 return -EIO;
1282                         }
1283                         break;
1284                 case Value:
1285                         if (reg_info[i].width != sizeof(unsigned long))
1286                                 return -EIO;
1287                         FRAME_REG(i, unsigned long) = cfa + state.regs[i].value
1288                             * state.dataAlign;
1289                         break;
1290                 case Memory:
1291                         addr = cfa + state.regs[i].value * state.dataAlign;
1292
1293                         if ((state.regs[i].value * state.dataAlign)
1294                             % sizeof(unsigned long)
1295                             || addr < startLoc
1296                             || addr + sizeof(unsigned long) < addr
1297                             || addr + sizeof(unsigned long) > endLoc)
1298                                         return -EIO;
1299
1300                         switch (reg_info[i].width) {
1301                         case sizeof(u8):
1302                                 __get_user(FRAME_REG(i, u8),
1303                                            (u8 __user *)addr);
1304                                 break;
1305                         case sizeof(u16):
1306                                 __get_user(FRAME_REG(i, u16),
1307                                            (u16 __user *)addr);
1308                                 break;
1309                         case sizeof(u32):
1310                                 __get_user(FRAME_REG(i, u32),
1311                                            (u32 __user *)addr);
1312                                 break;
1313 #ifdef CONFIG_64BIT
1314                         case sizeof(u64):
1315                                 __get_user(FRAME_REG(i, u64),
1316                                            (u64 __user *)addr);
1317                                 break;
1318 #endif
1319                         default:
1320                                 return -EIO;
1321                         }
1322
1323                         break;
1324                 }
1325                 unw_debug("r%d: 0x%lx ", i, *fptr);
1326         }
1327
1328         return 0;
1329 #undef FRAME_REG
1330 }
1331 EXPORT_SYMBOL(arc_unwind);