perf unwind: Fix looking up dwarf unwind stack info
[muen/linux.git] / tools / perf / util / unwind-libunwind-local.c
1 /*
2  * Post mortem Dwarf CFI based unwinding on top of regs and stack dumps.
3  *
4  * Lots of this code have been borrowed or heavily inspired from parts of
5  * the libunwind 0.99 code which are (amongst other contributors I may have
6  * forgotten):
7  *
8  * Copyright (C) 2002-2007 Hewlett-Packard Co
9  *      Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
10  *
11  * And the bugs have been added by:
12  *
13  * Copyright (C) 2010, Frederic Weisbecker <fweisbec@gmail.com>
14  * Copyright (C) 2012, Jiri Olsa <jolsa@redhat.com>
15  *
16  */
17
18 #include <elf.h>
19 #include <gelf.h>
20 #include <fcntl.h>
21 #include <string.h>
22 #include <unistd.h>
23 #include <sys/mman.h>
24 #include <linux/list.h>
25 #ifndef REMOTE_UNWIND_LIBUNWIND
26 #include <libunwind.h>
27 #include <libunwind-ptrace.h>
28 #endif
29 #include "callchain.h"
30 #include "thread.h"
31 #include "session.h"
32 #include "perf_regs.h"
33 #include "unwind.h"
34 #include "symbol.h"
35 #include "util.h"
36 #include "debug.h"
37 #include "asm/bug.h"
38 #include "dso.h"
39
40 extern int
41 UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as,
42                                     unw_word_t ip,
43                                     unw_dyn_info_t *di,
44                                     unw_proc_info_t *pi,
45                                     int need_unwind_info, void *arg);
46
47 #define dwarf_search_unwind_table UNW_OBJ(dwarf_search_unwind_table)
48
49 extern int
50 UNW_OBJ(dwarf_find_debug_frame) (int found, unw_dyn_info_t *di_debug,
51                                  unw_word_t ip,
52                                  unw_word_t segbase,
53                                  const char *obj_name, unw_word_t start,
54                                  unw_word_t end);
55
56 #define dwarf_find_debug_frame UNW_OBJ(dwarf_find_debug_frame)
57
58 #define DW_EH_PE_FORMAT_MASK    0x0f    /* format of the encoded value */
59 #define DW_EH_PE_APPL_MASK      0x70    /* how the value is to be applied */
60
61 /* Pointer-encoding formats: */
62 #define DW_EH_PE_omit           0xff
63 #define DW_EH_PE_ptr            0x00    /* pointer-sized unsigned value */
64 #define DW_EH_PE_udata4         0x03    /* unsigned 32-bit value */
65 #define DW_EH_PE_udata8         0x04    /* unsigned 64-bit value */
66 #define DW_EH_PE_sdata4         0x0b    /* signed 32-bit value */
67 #define DW_EH_PE_sdata8         0x0c    /* signed 64-bit value */
68
69 /* Pointer-encoding application: */
70 #define DW_EH_PE_absptr         0x00    /* absolute value */
71 #define DW_EH_PE_pcrel          0x10    /* rel. to addr. of encoded value */
72
73 /*
74  * The following are not documented by LSB v1.3, yet they are used by
75  * GCC, presumably they aren't documented by LSB since they aren't
76  * used on Linux:
77  */
78 #define DW_EH_PE_funcrel        0x40    /* start-of-procedure-relative */
79 #define DW_EH_PE_aligned        0x50    /* aligned pointer */
80
81 /* Flags intentionaly not handled, since they're not needed:
82  * #define DW_EH_PE_indirect      0x80
83  * #define DW_EH_PE_uleb128       0x01
84  * #define DW_EH_PE_udata2        0x02
85  * #define DW_EH_PE_sleb128       0x09
86  * #define DW_EH_PE_sdata2        0x0a
87  * #define DW_EH_PE_textrel       0x20
88  * #define DW_EH_PE_datarel       0x30
89  */
90
91 struct unwind_info {
92         struct perf_sample      *sample;
93         struct machine          *machine;
94         struct thread           *thread;
95 };
96
97 #define dw_read(ptr, type, end) ({      \
98         type *__p = (type *) ptr;       \
99         type  __v;                      \
100         if ((__p + 1) > (type *) end)   \
101                 return -EINVAL;         \
102         __v = *__p++;                   \
103         ptr = (typeof(ptr)) __p;        \
104         __v;                            \
105         })
106
107 static int __dw_read_encoded_value(u8 **p, u8 *end, u64 *val,
108                                    u8 encoding)
109 {
110         u8 *cur = *p;
111         *val = 0;
112
113         switch (encoding) {
114         case DW_EH_PE_omit:
115                 *val = 0;
116                 goto out;
117         case DW_EH_PE_ptr:
118                 *val = dw_read(cur, unsigned long, end);
119                 goto out;
120         default:
121                 break;
122         }
123
124         switch (encoding & DW_EH_PE_APPL_MASK) {
125         case DW_EH_PE_absptr:
126                 break;
127         case DW_EH_PE_pcrel:
128                 *val = (unsigned long) cur;
129                 break;
130         default:
131                 return -EINVAL;
132         }
133
134         if ((encoding & 0x07) == 0x00)
135                 encoding |= DW_EH_PE_udata4;
136
137         switch (encoding & DW_EH_PE_FORMAT_MASK) {
138         case DW_EH_PE_sdata4:
139                 *val += dw_read(cur, s32, end);
140                 break;
141         case DW_EH_PE_udata4:
142                 *val += dw_read(cur, u32, end);
143                 break;
144         case DW_EH_PE_sdata8:
145                 *val += dw_read(cur, s64, end);
146                 break;
147         case DW_EH_PE_udata8:
148                 *val += dw_read(cur, u64, end);
149                 break;
150         default:
151                 return -EINVAL;
152         }
153
154  out:
155         *p = cur;
156         return 0;
157 }
158
159 #define dw_read_encoded_value(ptr, end, enc) ({                 \
160         u64 __v;                                                \
161         if (__dw_read_encoded_value(&ptr, end, &__v, enc)) {    \
162                 return -EINVAL;                                 \
163         }                                                       \
164         __v;                                                    \
165         })
166
167 static u64 elf_section_offset(int fd, const char *name)
168 {
169         Elf *elf;
170         GElf_Ehdr ehdr;
171         GElf_Shdr shdr;
172         u64 offset = 0;
173
174         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
175         if (elf == NULL)
176                 return 0;
177
178         do {
179                 if (gelf_getehdr(elf, &ehdr) == NULL)
180                         break;
181
182                 if (!elf_section_by_name(elf, &ehdr, &shdr, name, NULL))
183                         break;
184
185                 offset = shdr.sh_offset;
186         } while (0);
187
188         elf_end(elf);
189         return offset;
190 }
191
192 #ifndef NO_LIBUNWIND_DEBUG_FRAME
193 static int elf_is_exec(int fd, const char *name)
194 {
195         Elf *elf;
196         GElf_Ehdr ehdr;
197         int retval = 0;
198
199         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
200         if (elf == NULL)
201                 return 0;
202         if (gelf_getehdr(elf, &ehdr) == NULL)
203                 goto out;
204
205         retval = (ehdr.e_type == ET_EXEC);
206
207 out:
208         elf_end(elf);
209         pr_debug("unwind: elf_is_exec(%s): %d\n", name, retval);
210         return retval;
211 }
212 #endif
213
214 struct table_entry {
215         u32 start_ip_offset;
216         u32 fde_offset;
217 };
218
219 struct eh_frame_hdr {
220         unsigned char version;
221         unsigned char eh_frame_ptr_enc;
222         unsigned char fde_count_enc;
223         unsigned char table_enc;
224
225         /*
226          * The rest of the header is variable-length and consists of the
227          * following members:
228          *
229          *      encoded_t eh_frame_ptr;
230          *      encoded_t fde_count;
231          */
232
233         /* A single encoded pointer should not be more than 8 bytes. */
234         u64 enc[2];
235
236         /*
237          * struct {
238          *    encoded_t start_ip;
239          *    encoded_t fde_addr;
240          * } binary_search_table[fde_count];
241          */
242         char data[0];
243 } __packed;
244
245 static int unwind_spec_ehframe(struct dso *dso, struct machine *machine,
246                                u64 offset, u64 *table_data, u64 *segbase,
247                                u64 *fde_count)
248 {
249         struct eh_frame_hdr hdr;
250         u8 *enc = (u8 *) &hdr.enc;
251         u8 *end = (u8 *) &hdr.data;
252         ssize_t r;
253
254         r = dso__data_read_offset(dso, machine, offset,
255                                   (u8 *) &hdr, sizeof(hdr));
256         if (r != sizeof(hdr))
257                 return -EINVAL;
258
259         /* We dont need eh_frame_ptr, just skip it. */
260         dw_read_encoded_value(enc, end, hdr.eh_frame_ptr_enc);
261
262         *fde_count  = dw_read_encoded_value(enc, end, hdr.fde_count_enc);
263         *segbase    = offset;
264         *table_data = (enc - (u8 *) &hdr) + offset;
265         return 0;
266 }
267
268 static int read_unwind_spec_eh_frame(struct dso *dso, struct machine *machine,
269                                      u64 *table_data, u64 *segbase,
270                                      u64 *fde_count)
271 {
272         int ret = -EINVAL, fd;
273         u64 offset = dso->data.eh_frame_hdr_offset;
274
275         if (offset == 0) {
276                 fd = dso__data_get_fd(dso, machine);
277                 if (fd < 0)
278                         return -EINVAL;
279
280                 /* Check the .eh_frame section for unwinding info */
281                 offset = elf_section_offset(fd, ".eh_frame_hdr");
282                 dso->data.eh_frame_hdr_offset = offset;
283                 dso__data_put_fd(dso);
284         }
285
286         if (offset)
287                 ret = unwind_spec_ehframe(dso, machine, offset,
288                                           table_data, segbase,
289                                           fde_count);
290
291         return ret;
292 }
293
294 #ifndef NO_LIBUNWIND_DEBUG_FRAME
295 static int read_unwind_spec_debug_frame(struct dso *dso,
296                                         struct machine *machine, u64 *offset)
297 {
298         int fd;
299         u64 ofs = dso->data.debug_frame_offset;
300
301         /* debug_frame can reside in:
302          *  - dso
303          *  - debug pointed by symsrc_filename
304          *  - gnu_debuglink, which doesn't necessary
305          *    has to be pointed by symsrc_filename
306          */
307         if (ofs == 0) {
308                 fd = dso__data_get_fd(dso, machine);
309                 if (fd >= 0) {
310                         ofs = elf_section_offset(fd, ".debug_frame");
311                         dso__data_put_fd(dso);
312                 }
313
314                 if (ofs <= 0) {
315                         fd = open(dso->symsrc_filename, O_RDONLY);
316                         if (fd >= 0) {
317                                 ofs = elf_section_offset(fd, ".debug_frame");
318                                 close(fd);
319                         }
320                 }
321
322                 if (ofs <= 0) {
323                         char *debuglink = malloc(PATH_MAX);
324                         int ret = 0;
325
326                         ret = dso__read_binary_type_filename(
327                                 dso, DSO_BINARY_TYPE__DEBUGLINK,
328                                 machine->root_dir, debuglink, PATH_MAX);
329                         if (!ret) {
330                                 fd = open(debuglink, O_RDONLY);
331                                 if (fd >= 0) {
332                                         ofs = elf_section_offset(fd,
333                                                         ".debug_frame");
334                                         close(fd);
335                                 }
336                         }
337                         if (ofs > 0) {
338                                 if (dso->symsrc_filename != NULL) {
339                                         pr_warning(
340                                                 "%s: overwrite symsrc(%s,%s)\n",
341                                                         __func__,
342                                                         dso->symsrc_filename,
343                                                         debuglink);
344                                         free(dso->symsrc_filename);
345                                 }
346                                 dso->symsrc_filename = debuglink;
347                         } else {
348                                 free(debuglink);
349                         }
350                 }
351
352                 dso->data.debug_frame_offset = ofs;
353         }
354
355         *offset = ofs;
356         if (*offset)
357                 return 0;
358
359         return -EINVAL;
360 }
361 #endif
362
363 static struct map *find_map(unw_word_t ip, struct unwind_info *ui)
364 {
365         struct addr_location al;
366
367         thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
368                               MAP__FUNCTION, ip, &al);
369         if (!al.map) {
370                 /*
371                  * We've seen cases (softice) where DWARF unwinder went
372                  * through non executable mmaps, which we need to lookup
373                  * in MAP__VARIABLE tree.
374                  */
375                 thread__find_addr_map(ui->thread, PERF_RECORD_MISC_USER,
376                                       MAP__VARIABLE, ip, &al);
377         }
378         return al.map;
379 }
380
381 static int
382 find_proc_info(unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi,
383                int need_unwind_info, void *arg)
384 {
385         struct unwind_info *ui = arg;
386         struct map *map;
387         unw_dyn_info_t di;
388         u64 table_data, segbase, fde_count;
389         int ret = -EINVAL;
390
391         map = find_map(ip, ui);
392         if (!map || !map->dso)
393                 return -EINVAL;
394
395         pr_debug("unwind: find_proc_info dso %s\n", map->dso->name);
396
397         /* Check the .eh_frame section for unwinding info */
398         if (!read_unwind_spec_eh_frame(map->dso, ui->machine,
399                                        &table_data, &segbase, &fde_count)) {
400                 memset(&di, 0, sizeof(di));
401                 di.format   = UNW_INFO_FORMAT_REMOTE_TABLE;
402                 di.start_ip = map->start;
403                 di.end_ip   = map->end;
404                 di.u.rti.segbase    = map->start + segbase - map->pgoff;
405                 di.u.rti.table_data = map->start + table_data - map->pgoff;
406                 di.u.rti.table_len  = fde_count * sizeof(struct table_entry)
407                                       / sizeof(unw_word_t);
408                 ret = dwarf_search_unwind_table(as, ip, &di, pi,
409                                                 need_unwind_info, arg);
410         }
411
412 #ifndef NO_LIBUNWIND_DEBUG_FRAME
413         /* Check the .debug_frame section for unwinding info */
414         if (ret < 0 &&
415             !read_unwind_spec_debug_frame(map->dso, ui->machine, &segbase)) {
416                 int fd = dso__data_get_fd(map->dso, ui->machine);
417                 int is_exec = elf_is_exec(fd, map->dso->name);
418                 unw_word_t base = is_exec ? 0 : map->start;
419                 const char *symfile;
420
421                 if (fd >= 0)
422                         dso__data_put_fd(map->dso);
423
424                 symfile = map->dso->symsrc_filename ?: map->dso->name;
425
426                 memset(&di, 0, sizeof(di));
427                 if (dwarf_find_debug_frame(0, &di, ip, base, symfile,
428                                            map->start, map->end))
429                         return dwarf_search_unwind_table(as, ip, &di, pi,
430                                                          need_unwind_info, arg);
431         }
432 #endif
433
434         return ret;
435 }
436
437 static int access_fpreg(unw_addr_space_t __maybe_unused as,
438                         unw_regnum_t __maybe_unused num,
439                         unw_fpreg_t __maybe_unused *val,
440                         int __maybe_unused __write,
441                         void __maybe_unused *arg)
442 {
443         pr_err("unwind: access_fpreg unsupported\n");
444         return -UNW_EINVAL;
445 }
446
447 static int get_dyn_info_list_addr(unw_addr_space_t __maybe_unused as,
448                                   unw_word_t __maybe_unused *dil_addr,
449                                   void __maybe_unused *arg)
450 {
451         return -UNW_ENOINFO;
452 }
453
454 static int resume(unw_addr_space_t __maybe_unused as,
455                   unw_cursor_t __maybe_unused *cu,
456                   void __maybe_unused *arg)
457 {
458         pr_err("unwind: resume unsupported\n");
459         return -UNW_EINVAL;
460 }
461
462 static int
463 get_proc_name(unw_addr_space_t __maybe_unused as,
464               unw_word_t __maybe_unused addr,
465                 char __maybe_unused *bufp, size_t __maybe_unused buf_len,
466                 unw_word_t __maybe_unused *offp, void __maybe_unused *arg)
467 {
468         pr_err("unwind: get_proc_name unsupported\n");
469         return -UNW_EINVAL;
470 }
471
472 static int access_dso_mem(struct unwind_info *ui, unw_word_t addr,
473                           unw_word_t *data)
474 {
475         struct map *map;
476         ssize_t size;
477
478         map = find_map(addr, ui);
479         if (!map) {
480                 pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
481                 return -1;
482         }
483
484         if (!map->dso)
485                 return -1;
486
487         size = dso__data_read_addr(map->dso, map, ui->machine,
488                                    addr, (u8 *) data, sizeof(*data));
489
490         return !(size == sizeof(*data));
491 }
492
493 static int access_mem(unw_addr_space_t __maybe_unused as,
494                       unw_word_t addr, unw_word_t *valp,
495                       int __write, void *arg)
496 {
497         struct unwind_info *ui = arg;
498         struct stack_dump *stack = &ui->sample->user_stack;
499         u64 start, end;
500         int offset;
501         int ret;
502
503         /* Don't support write, probably not needed. */
504         if (__write || !stack || !ui->sample->user_regs.regs) {
505                 *valp = 0;
506                 return 0;
507         }
508
509         ret = perf_reg_value(&start, &ui->sample->user_regs,
510                              LIBUNWIND__ARCH_REG_SP);
511         if (ret)
512                 return ret;
513
514         end = start + stack->size;
515
516         /* Check overflow. */
517         if (addr + sizeof(unw_word_t) < addr)
518                 return -EINVAL;
519
520         if (addr < start || addr + sizeof(unw_word_t) >= end) {
521                 ret = access_dso_mem(ui, addr, valp);
522                 if (ret) {
523                         pr_debug("unwind: access_mem %p not inside range"
524                                  " 0x%" PRIx64 "-0x%" PRIx64 "\n",
525                                  (void *) (uintptr_t) addr, start, end);
526                         *valp = 0;
527                         return ret;
528                 }
529                 return 0;
530         }
531
532         offset = addr - start;
533         *valp  = *(unw_word_t *)&stack->data[offset];
534         pr_debug("unwind: access_mem addr %p val %lx, offset %d\n",
535                  (void *) (uintptr_t) addr, (unsigned long)*valp, offset);
536         return 0;
537 }
538
539 static int access_reg(unw_addr_space_t __maybe_unused as,
540                       unw_regnum_t regnum, unw_word_t *valp,
541                       int __write, void *arg)
542 {
543         struct unwind_info *ui = arg;
544         int id, ret;
545         u64 val;
546
547         /* Don't support write, I suspect we don't need it. */
548         if (__write) {
549                 pr_err("unwind: access_reg w %d\n", regnum);
550                 return 0;
551         }
552
553         if (!ui->sample->user_regs.regs) {
554                 *valp = 0;
555                 return 0;
556         }
557
558         id = LIBUNWIND__ARCH_REG_ID(regnum);
559         if (id < 0)
560                 return -EINVAL;
561
562         ret = perf_reg_value(&val, &ui->sample->user_regs, id);
563         if (ret) {
564                 pr_err("unwind: can't read reg %d\n", regnum);
565                 return ret;
566         }
567
568         *valp = (unw_word_t) val;
569         pr_debug("unwind: reg %d, val %lx\n", regnum, (unsigned long)*valp);
570         return 0;
571 }
572
573 static void put_unwind_info(unw_addr_space_t __maybe_unused as,
574                             unw_proc_info_t *pi __maybe_unused,
575                             void *arg __maybe_unused)
576 {
577         pr_debug("unwind: put_unwind_info called\n");
578 }
579
580 static int entry(u64 ip, struct thread *thread,
581                  unwind_entry_cb_t cb, void *arg)
582 {
583         struct unwind_entry e;
584         struct addr_location al;
585
586         thread__find_addr_location(thread, PERF_RECORD_MISC_USER,
587                                    MAP__FUNCTION, ip, &al);
588
589         e.ip = al.addr;
590         e.map = al.map;
591         e.sym = al.sym;
592
593         pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n",
594                  al.sym ? al.sym->name : "''",
595                  ip,
596                  al.map ? al.map->map_ip(al.map, ip) : (u64) 0);
597
598         return cb(&e, arg);
599 }
600
601 static void display_error(int err)
602 {
603         switch (err) {
604         case UNW_EINVAL:
605                 pr_err("unwind: Only supports local.\n");
606                 break;
607         case UNW_EUNSPEC:
608                 pr_err("unwind: Unspecified error.\n");
609                 break;
610         case UNW_EBADREG:
611                 pr_err("unwind: Register unavailable.\n");
612                 break;
613         default:
614                 break;
615         }
616 }
617
618 static unw_accessors_t accessors = {
619         .find_proc_info         = find_proc_info,
620         .put_unwind_info        = put_unwind_info,
621         .get_dyn_info_list_addr = get_dyn_info_list_addr,
622         .access_mem             = access_mem,
623         .access_reg             = access_reg,
624         .access_fpreg           = access_fpreg,
625         .resume                 = resume,
626         .get_proc_name          = get_proc_name,
627 };
628
629 static int _unwind__prepare_access(struct thread *thread)
630 {
631         if (callchain_param.record_mode != CALLCHAIN_DWARF)
632                 return 0;
633
634         thread->addr_space = unw_create_addr_space(&accessors, 0);
635         if (!thread->addr_space) {
636                 pr_err("unwind: Can't create unwind address space.\n");
637                 return -ENOMEM;
638         }
639
640         unw_set_caching_policy(thread->addr_space, UNW_CACHE_GLOBAL);
641         return 0;
642 }
643
644 static void _unwind__flush_access(struct thread *thread)
645 {
646         if (callchain_param.record_mode != CALLCHAIN_DWARF)
647                 return;
648
649         unw_flush_cache(thread->addr_space, 0, 0);
650 }
651
652 static void _unwind__finish_access(struct thread *thread)
653 {
654         if (callchain_param.record_mode != CALLCHAIN_DWARF)
655                 return;
656
657         unw_destroy_addr_space(thread->addr_space);
658 }
659
660 static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb,
661                        void *arg, int max_stack)
662 {
663         u64 val;
664         unw_word_t ips[max_stack];
665         unw_addr_space_t addr_space;
666         unw_cursor_t c;
667         int ret, i = 0;
668
669         ret = perf_reg_value(&val, &ui->sample->user_regs,
670                              LIBUNWIND__ARCH_REG_IP);
671         if (ret)
672                 return ret;
673
674         ips[i++] = (unw_word_t) val;
675
676         /*
677          * If we need more than one entry, do the DWARF
678          * unwind itself.
679          */
680         if (max_stack - 1 > 0) {
681                 WARN_ONCE(!ui->thread, "WARNING: ui->thread is NULL");
682                 addr_space = ui->thread->addr_space;
683
684                 if (addr_space == NULL)
685                         return -1;
686
687                 ret = unw_init_remote(&c, addr_space, ui);
688                 if (ret)
689                         display_error(ret);
690
691                 while (!ret && (unw_step(&c) > 0) && i < max_stack) {
692                         unw_get_reg(&c, UNW_REG_IP, &ips[i]);
693                         ++i;
694                 }
695
696                 max_stack = i;
697         }
698
699         /*
700          * Display what we got based on the order setup.
701          */
702         for (i = 0; i < max_stack && !ret; i++) {
703                 int j = i;
704
705                 if (callchain_param.order == ORDER_CALLER)
706                         j = max_stack - i - 1;
707                 ret = ips[j] ? entry(ips[j], ui->thread, cb, arg) : 0;
708         }
709
710         return ret;
711 }
712
713 static int _unwind__get_entries(unwind_entry_cb_t cb, void *arg,
714                         struct thread *thread,
715                         struct perf_sample *data, int max_stack)
716 {
717         struct unwind_info ui = {
718                 .sample       = data,
719                 .thread       = thread,
720                 .machine      = thread->mg->machine,
721         };
722
723         if (!data->user_regs.regs)
724                 return -EINVAL;
725
726         if (max_stack <= 0)
727                 return -EINVAL;
728
729         return get_entries(&ui, cb, arg, max_stack);
730 }
731
732 static struct unwind_libunwind_ops
733 _unwind_libunwind_ops = {
734         .prepare_access = _unwind__prepare_access,
735         .flush_access   = _unwind__flush_access,
736         .finish_access  = _unwind__finish_access,
737         .get_entries    = _unwind__get_entries,
738 };
739
740 #ifndef REMOTE_UNWIND_LIBUNWIND
741 struct unwind_libunwind_ops *
742 local_unwind_libunwind_ops = &_unwind_libunwind_ops;
743 #endif