OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [pei-x86_64.c] - Blame information for rev 840

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* BFD back-end for Intel 386 PE IMAGE COFF files.
2 225 jeremybenn
   Copyright 2006, 2007, 2009 Free Software Foundation, Inc.
3 24 jeremybenn
 
4
   This file is part of BFD, the Binary File Descriptor library.
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 as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
 
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
 
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19
   MA 02110-1301, USA.
20
 
21
   Written by Kai Tietz, OneVision Software GmbH&CoKg.  */
22
 
23
#include "sysdep.h"
24
#include "bfd.h"
25
 
26
#define TARGET_SYM              x86_64pei_vec
27
#define TARGET_NAME             "pei-x86-64"
28
#define COFF_IMAGE_WITH_PE
29
#define COFF_WITH_PE
30
#define COFF_WITH_pex64
31
#define PCRELOFFSET             TRUE
32
#define TARGET_UNDERSCORE       '_'
33 225 jeremybenn
/* Long section names not allowed in executable images, only object files.  */
34
#define COFF_LONG_SECTION_NAMES 0
35 24 jeremybenn
#define COFF_SUPPORT_GNU_LINKONCE
36
#define COFF_LONG_FILENAMES
37 225 jeremybenn
#define PDATA_ROW_SIZE  (3 * 4)
38 24 jeremybenn
 
39
#define COFF_SECTION_ALIGNMENT_ENTRIES \
40
{ COFF_SECTION_NAME_EXACT_MATCH (".bss"), \
41
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
42
{ COFF_SECTION_NAME_EXACT_MATCH (".data"), \
43
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
44
{ COFF_SECTION_NAME_EXACT_MATCH (".rdata"), \
45
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
46
{ COFF_SECTION_NAME_EXACT_MATCH (".text"), \
47
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
48
{ COFF_SECTION_NAME_PARTIAL_MATCH (".idata"), \
49
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
50
{ COFF_SECTION_NAME_EXACT_MATCH (".pdata"), \
51
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 2 }, \
52
{ COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
53
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
54
{ COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi."), \
55
  COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }
56
 
57 225 jeremybenn
/* Note we have to make sure not to include headers twice.
58
   Not all headers are wrapped in #ifdef guards, so we define
59
   PEI_HEADERS to prevent double including in coff-x86_64.c  */
60
#define PEI_HEADERS
61
#include "sysdep.h"
62
#include "bfd.h"
63
#include "libbfd.h"
64
#include "coff/x86_64.h"
65
#include "coff/internal.h"
66
#include "coff/pe.h"
67
#include "libcoff.h"
68
#include "libpei.h"
69
#include "libiberty.h"
70
 
71
#undef AOUTSZ
72
#define AOUTSZ          PEPAOUTSZ
73
#define PEAOUTHDR       PEPAOUTHDR
74
 
75
static const char *pex_regs[16] = {
76
  "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
77
  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
78
};
79
 
80
static void
81
pex64_get_runtime_function (bfd *abfd, struct pex64_runtime_function *rf,
82
                            const void *data)
83
{
84
  const struct external_pex64_runtime_function *ex_rf =
85
    (const struct external_pex64_runtime_function *) data;
86
  rf->rva_BeginAddress = bfd_get_32 (abfd, ex_rf->rva_BeginAddress);
87
  rf->rva_EndAddress = bfd_get_32 (abfd, ex_rf->rva_EndAddress);
88
  rf->rva_UnwindData =  bfd_get_32 (abfd, ex_rf->rva_UnwindData);
89
  rf->isChained = PEX64_IS_RUNTIME_FUNCTION_CHAINED (rf);
90
  rf->rva_UnwindData = PEX64_GET_UNWINDDATA_UNIFIED_RVA (rf);
91
}
92
 
93
static void
94
pex64_get_unwind_info (bfd *abfd, struct pex64_unwind_info *ui, void *data)
95
{
96
  struct external_pex64_unwind_info *ex_ui =
97
    (struct external_pex64_unwind_info *) data;
98
  bfd_byte *ex_dta = (bfd_byte *) data;
99
 
100
  memset (ui, 0, sizeof (struct pex64_unwind_info));
101
  ui->Version = PEX64_UWI_VERSION (ex_ui->Version_Flags);
102
  ui->Flags = PEX64_UWI_FLAGS (ex_ui->Version_Flags);
103
  ui->SizeOfPrologue = (bfd_vma) ex_ui->SizeOfPrologue;
104
  ui->CountOfCodes = (bfd_vma) ex_ui->CountOfCodes;
105
  ui->FrameRegister = PEX64_UWI_FRAMEREG (ex_ui->FrameRegisterOffset);
106
  ui->FrameOffset = PEX64_UWI_FRAMEOFF (ex_ui->FrameRegisterOffset);
107
  ui->sizeofUnwindCodes = PEX64_UWI_SIZEOF_UWCODE_ARRAY (ui->CountOfCodes);
108
  ui->SizeOfBlock = ui->sizeofUnwindCodes + 4;
109
  ui->rawUnwindCodes = &ex_dta[4];
110
  ex_dta += ui->SizeOfBlock;
111
  switch (ui->Flags)
112
    {
113
    case UNW_FLAG_EHANDLER:
114
      ui->rva_ExceptionHandler = bfd_get_32 (abfd, ex_dta);
115
      break;
116
    case UNW_FLAG_UHANDLER:
117
      ui->rva_TerminationHandler = bfd_get_32 (abfd, ex_dta);
118
      break;
119
    case UNW_FLAG_FHANDLER:
120
      ui->rva_FrameHandler = bfd_get_32 (abfd, ex_dta);
121
      ui->FrameHandlerArgument = bfd_get_32 (abfd, ex_dta + 4);
122
      ui->SizeOfBlock += 8;
123
      return;
124
    case UNW_FLAG_CHAININFO:
125
      ui->rva_FunctionEntry = bfd_get_32 (abfd, ex_dta);
126
      ui->SizeOfBlock += 4;
127
      return;
128
    default:
129
      return;
130
    }
131
  ex_dta += 4;
132
  ui->SizeOfBlock += 8;
133
  ui->CountOfScopes = bfd_get_32 (abfd, ex_dta);
134
  ex_dta += 4;
135
  ui->rawScopeEntries = ex_dta;
136
  ui->SizeOfBlock += (ui->CountOfScopes * PEX64_SCOPE_ENTRY_SIZE);
137
}
138
 
139
static void
140
pex64_get_scope_entry (bfd *abfd, struct pex64_scope_entry *se,
141
                       bfd_vma idx, const bfd_byte *x)
142
{
143
  const struct external_pex64_scope_entry *ex_se;
144
  x += (idx * PEX64_SCOPE_ENTRY_SIZE);
145
  ex_se = (const struct external_pex64_scope_entry *) x;
146
  memset (se, 0, sizeof (struct pex64_scope_entry));
147
  se->rva_BeginAddress = bfd_get_32 (abfd, ex_se->rva_BeginAddress);
148
  se->rva_EndAddress = bfd_get_32 (abfd, ex_se->rva_EndAddress);
149
  se->rva_HandlerAddress = bfd_get_32 (abfd, ex_se->rva_HandlerAddress);
150
  se->rva_JumpAddress = bfd_get_32 (abfd, ex_se->rva_JumpAddress);
151
}
152
 
153
static void
154
pex64_xdata_print_uwd_codes (FILE *file, struct pex64_unwind_info *ui,
155
                             bfd_vma pc_addr)
156
{
157
  bfd_vma i;
158
  bfd_vma tmp = 0;
159
  const bfd_byte *insns[256];
160
  bfd_vma insns_count = 0;
161
  const bfd_byte *dta = ui->rawUnwindCodes;
162
 
163
  if (ui->CountOfCodes == 0 || !dta)
164
    return;
165
 
166
  /* Sort array ascending. Note: it is stored in reversed order.  */
167
  for (i = 0; i < ui->CountOfCodes; i++)
168
    {
169
      const bfd_byte *t;
170
 
171
      t = insns[insns_count++] = &dta[i * 2];
172
      switch (PEX64_UNWCODE_CODE (t[1]))
173
        {
174
        case UWOP_PUSH_NONVOL:
175
        case UWOP_ALLOC_SMALL:
176
        case UWOP_SET_FPREG:
177
        case UWOP_PUSH_MACHFRAME:
178
          break;
179
        case UWOP_ALLOC_LARGE:
180
          if (PEX64_UNWCODE_INFO (t[1]) == 0)
181
            {
182
              i += 1;
183
              break;
184
            }
185
          else if (PEX64_UNWCODE_INFO (t[1]) == 1)
186
            {
187
              i += 2;
188
              break;
189
            }
190
          /* fall through.  */
191
        default:
192
          fprintf (file, "\t contains unknown code (%u).\n",
193
                   (unsigned int) PEX64_UNWCODE_CODE (t[1]));
194
          return;
195
        case UWOP_SAVE_NONVOL:
196
        case UWOP_SAVE_XMM:
197
        case UWOP_SAVE_XMM128:
198
          i++;
199
          break;
200
        case UWOP_SAVE_NONVOL_FAR:
201
        case UWOP_SAVE_XMM_FAR:
202
        case UWOP_SAVE_XMM128_FAR:
203
          i += 2;
204
          break;
205
        }
206
    }
207
  fprintf (file, "\t At pc 0x");
208
  fprintf_vma (file, pc_addr);
209
  fprintf (file, " there are the following saves (in logical order).\n");
210
  for (i = insns_count; i > 0;)
211
    {
212
      --i;
213
      dta = insns[i];
214
      fprintf (file, "\t  insn ends at pc+0x%02x: ", (unsigned int) dta[0]);
215
      switch (PEX64_UNWCODE_CODE (dta[1]))
216
        {
217
        case UWOP_PUSH_NONVOL:
218
          fprintf (file, "push %s.\n", pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
219
          break;
220
        case UWOP_ALLOC_LARGE:
221
          if (PEX64_UNWCODE_INFO (dta[1]) == 0)
222
            {
223
              tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
224
              tmp *= 8;
225
            }
226
          else
227
            tmp = (bfd_vma) (*((unsigned int *)&dta[2]));
228
          fprintf (file, "save stack region of size 0x");
229
          fprintf_vma (file, tmp);
230
          fprintf (file,".\n");
231
          break;
232
        case UWOP_ALLOC_SMALL:
233
          tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
234
          tmp += 1;
235
          tmp *= 8;
236
          fprintf (file, "save stack region of size 0x");
237
          fprintf_vma (file, tmp);
238
          fprintf (file,".\n");
239
          break;
240
        case UWOP_SET_FPREG:
241
          tmp = (bfd_vma) PEX64_UNWCODE_INFO (dta[1]);
242
          tmp *= 16;
243
          fprintf (file, "FPReg = (FrameReg) + 0x");
244
          fprintf_vma (file, tmp);
245
          fprintf (file, ".\n");
246
          break;
247
        case UWOP_SAVE_NONVOL:
248
          fprintf (file, "mov %s at 0x",
249
                   pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
250
          tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
251
          tmp *= 8;
252
          fprintf_vma (file, tmp);
253
          fprintf (file, ".\n");
254
          break;
255
        case UWOP_SAVE_NONVOL_FAR:
256
          fprintf (file, "mov %s at 0x",
257
                   pex_regs[PEX64_UNWCODE_INFO (dta[1])]);
258
          tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
259
          fprintf_vma (file, tmp);
260
          fprintf (file, ".\n");
261
          break;
262
        case UWOP_SAVE_XMM:
263
          tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
264
          tmp *= 8;
265
          fprintf (file, "mov mm%u at 0x",
266
                   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
267
          fprintf_vma (file, tmp);
268
          fprintf (file, ".\n");
269
          break;
270
        case UWOP_SAVE_XMM_FAR:
271
          tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
272
          fprintf (file, "mov mm%u at 0x",
273
                   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
274
          fprintf_vma (file, tmp);
275
          fprintf (file, ".\n");
276
          break;
277
        case UWOP_SAVE_XMM128:
278
          tmp = (bfd_vma) (*((unsigned short *) &dta[2]));
279
          tmp *= 16;
280
          fprintf (file, "mov xmm%u at 0x",
281
                   (unsigned int) PEX64_UNWCODE_INFO ( dta[1]));
282
          fprintf_vma (file, tmp);
283
          fprintf (file, ".\n");
284
          break;
285
        case UWOP_SAVE_XMM128_FAR:
286
          tmp = (bfd_vma) (*((unsigned int *) &dta[2]));
287
          fprintf (file, "mov xmm%u at 0x",
288
                   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
289
          fprintf_vma (file, tmp);
290
          fprintf (file, ".\n");
291
          break;
292
        case UWOP_PUSH_MACHFRAME:
293
          fprintf (file, "interrupt entry (SS, old RSP, EFLAGS, CS, RIP");
294
          if (PEX64_UNWCODE_INFO (dta[1]) == 0)
295
            {
296
              fprintf (file, ")");
297
            }
298
          else if (PEX64_UNWCODE_INFO (dta[1]) == 1)
299
            {
300
              fprintf (file, ",ErrorCode)");
301
            }
302
          else
303
            fprintf (file, ", unknown(%u))",
304
                     (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
305
          fprintf (file,".\n");
306
          break;
307
        default:
308
          fprintf (file, "unknown code %u.\n",
309
                   (unsigned int) PEX64_UNWCODE_INFO (dta[1]));
310
          break;
311
      }
312
    }
313
}
314
 
315
static asection *
316
pex64_get_section_by_rva (bfd *abfd, bfd_vma addr, const char *sec_name)
317
{
318
  asection *section = bfd_get_section_by_name (abfd, sec_name);
319
  bfd_vma vsize;
320
  bfd_size_type datasize = 0;
321
 
322
  if (section == NULL
323
      || coff_section_data (abfd, section) == NULL
324
      || pei_section_data (abfd, section) == NULL)
325
    return NULL;
326
  vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
327
  datasize = section->size;
328
  if (!datasize || vsize > addr || (vsize + datasize) < addr)
329
    return NULL;
330
  return section;
331
}
332
 
333
static void
334
pex64_dump_xdata (FILE *file, bfd *abfd, bfd_vma addr, bfd_vma pc_addr)
335
{
336
  asection *section = pex64_get_section_by_rva (abfd, addr, ".rdata");
337
  bfd_vma vsize;
338
  bfd_byte *data = NULL;
339
  bfd_vma i;
340
 
341
  if (!section)
342
    section = pex64_get_section_by_rva (abfd, addr, ".data");
343
  if (!section)
344
    section = pex64_get_section_by_rva (abfd, addr, ".xdata");
345
  if (!section)
346
    {
347
      section = pex64_get_section_by_rva (abfd, addr, ".pdata");
348
      if (section)
349
        {
350
          fprintf (file, "\t Shares information with pdata element at 0x");
351
          fprintf_vma (file, addr + pe_data (abfd)->pe_opthdr.ImageBase);
352
          fprintf (file, ".\n");
353
        }
354
    }
355
  if (!section)
356
    return;
357
  vsize = section->vma - pe_data (abfd)->pe_opthdr.ImageBase;
358
  addr -= vsize;
359
  if (bfd_malloc_and_get_section (abfd, section, &data))
360
    {
361
      struct pex64_unwind_info ui;
362
 
363
      if (!data)
364
        return;
365
 
366
      pex64_get_unwind_info (abfd, &ui, &data[addr]);
367
 
368
      if (ui.Version != 1)
369
        {
370
          fprintf (file, "\tVersion %u (unknown).\n", (unsigned int) ui.Version);
371
          return;
372
        }
373
 
374
      fprintf (file, "\tFlags: ");
375
      switch (ui.Flags)
376
        {
377
        case UNW_FLAG_NHANDLER:
378
          fprintf (file, "UNW_FLAG_NHANDLER");
379
          break;
380
        case UNW_FLAG_EHANDLER:
381
          fprintf (file, "UNW_FLAG_EHANDLER");
382
          break;
383
        case UNW_FLAG_UHANDLER:
384
          fprintf (file, "UNW_FLAG_UHANDLER");
385
          break;
386
        case UNW_FLAG_FHANDLER:
387
          fprintf (file, "UNW_FLAG_FHANDLER = (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER)");
388
          break;
389
        case UNW_FLAG_CHAININFO:
390
          fprintf (file, "UNW_FLAG_CHAININFO");
391
          break;
392
        default:
393
          fprintf (file, "unknown flags value 0x%x", (unsigned int) ui.Flags);
394
          break;
395
        }
396
      fprintf (file, ".\n");
397
      if (ui.CountOfCodes != 0)
398
        fprintf (file, "\tEntry has %u codes.", (unsigned int) ui.CountOfCodes);
399
      fprintf (file, "\tPrologue size: %u, Frame offset = 0x%x.\n",
400
               (unsigned int) ui.SizeOfPrologue, (unsigned int) ui.FrameOffset);
401
      fprintf (file, "\tFrame register is %s.\n",
402
        ui.FrameRegister == 0 ? "CFA"
403
                              : pex_regs[(unsigned int) ui.FrameRegister]);
404
 
405
      pex64_xdata_print_uwd_codes (file, &ui, pc_addr);
406
 
407
      switch (ui.Flags)
408
        {
409
        case UNW_FLAG_NHANDLER:
410
          return;
411
        case UNW_FLAG_EHANDLER:
412
          fprintf (file, "\texception_handler at 0x%x.\n", (unsigned int) ui.rva_ExceptionHandler);
413
          break;
414
        case UNW_FLAG_UHANDLER:
415
          fprintf (file, "\ttermination_handler at 0x%x.\n", (unsigned int) ui.rva_TerminationHandler);
416
        case UNW_FLAG_FHANDLER:
417
          fprintf (file, "\tframe_handler at 0x%x.\n", (unsigned int) ui.rva_FrameHandler);
418
          fprintf (file, "\t Argument for FrameHandler: 0x%x.\n",
419
                   (unsigned int) ui.FrameHandlerArgument);
420
          return;
421
        case UNW_FLAG_CHAININFO:
422
          fprintf (file, "\t Function Entry: 0x%x\n", (unsigned int) ui.rva_FunctionEntry);
423
          return;
424
        default:
425
          fprintf (file, "\t Unknown flag value of 0x%x\n", (unsigned int) ui.Flags);
426
          return;
427
        }
428
      fprintf (file, "\t 0x%x # of scope(s)\n", (unsigned int) ui.CountOfScopes);
429
      for (i = 0; i < ui.CountOfScopes; i++)
430
        {
431
          struct pex64_scope_entry se;
432
          pex64_get_scope_entry (abfd, &se, i, ui.rawScopeEntries);
433
          fprintf (file, "\t scope #%u: BeginAddress: 0x%x, EndAddress: 0x%x,"
434
                   "\n\t\tHandlerAddress:0x%x, JumpTarget:0x%x\n",
435
                   (unsigned int) (i + 1),
436
                   (unsigned int) se.rva_BeginAddress,
437
                   (unsigned int) se.rva_EndAddress,
438
                   (unsigned int) se.rva_HandlerAddress,
439
                   (unsigned int) se.rva_JumpAddress);
440
        }
441
    }
442
  if (data != NULL)
443
    free (data);
444
}
445
 
446
static bfd_boolean
447
pex64_bfd_print_pdata (bfd *abfd, void *vfile)
448
{
449
  FILE *file = (FILE *) vfile;
450
  bfd_byte *data = NULL;
451
  asection *section = bfd_get_section_by_name (abfd, ".pdata");
452
  bfd_size_type datasize = 0;
453
  bfd_size_type i;
454
  bfd_size_type start, stop;
455
  int onaline = PDATA_ROW_SIZE;
456
 
457
  if (section == NULL
458
      || coff_section_data (abfd, section) == NULL
459
      || pei_section_data (abfd, section) == NULL)
460
    return TRUE;
461
 
462
  stop = pei_section_data (abfd, section)->virt_size;
463
  if ((stop % onaline) != 0)
464
    fprintf (file,
465
             _("warning: .pdata section size (%ld) is not a multiple of %d\n"),
466
             (long) stop, onaline);
467
 
468
  fprintf (file,
469
           _("\nThe Function Table (interpreted .pdata section contents)\n"));
470
 
471
  fprintf (file, _("vma:\t\t\tBeginAddress\t EndAddress\t  UnwindData\n"));
472
 
473
  datasize = section->size;
474
  if (datasize == 0)
475
    return TRUE;
476
 
477
  if (!bfd_malloc_and_get_section (abfd, section, &data))
478
    {
479
      if (data != NULL)
480
        free (data);
481
      return FALSE;
482
    }
483
 
484
  start = 0;
485
 
486
  for (i = start; i < stop; i += onaline)
487
    {
488
      struct pex64_runtime_function rf;
489
 
490
      if (i + PDATA_ROW_SIZE > stop)
491
        break;
492
      pex64_get_runtime_function (abfd, &rf, &data[i]);
493
 
494
      if (rf.rva_BeginAddress == 0 && rf.rva_EndAddress == 0
495
          && rf.rva_UnwindData == 0)
496
        /* We are probably into the padding of the section now.  */
497
        break;
498
 
499
      fputc (' ', file);
500
      fprintf_vma (file, i + section->vma);
501
      fprintf (file, ":\t");
502
      rf.rva_BeginAddress += pe_data (abfd)->pe_opthdr.ImageBase;
503
      fprintf_vma (file, rf.rva_BeginAddress);
504
      fputc (' ', file);
505
      rf.rva_EndAddress += pe_data (abfd)->pe_opthdr.ImageBase;
506
      fprintf_vma (file, rf.rva_EndAddress);
507
      fputc (' ', file);
508
      fprintf_vma (file, rf.rva_UnwindData);
509
      fprintf (file, "\n");
510
 
511
      if (rf.rva_UnwindData != 0)
512
        {
513
          if (rf.isChained)
514
            {
515
              fprintf (file, "\t shares information with pdata element at 0x");
516
              fprintf_vma (file, rf.rva_UnwindData + pe_data (abfd)->pe_opthdr.ImageBase);
517
              fprintf (file, ".\n");
518
            }
519
          else
520
            pex64_dump_xdata (file, abfd, rf.rva_UnwindData, rf.rva_BeginAddress);
521
        }
522
    }
523
 
524
  free (data);
525
 
526
  return TRUE;
527
}
528
 
529
#define bfd_pe_print_pdata   pex64_bfd_print_pdata
530
 
531 24 jeremybenn
#include "coff-x86_64.c"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.