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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libiberty/] [simple-object-elf.c] - Blame information for rev 746

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 736 jeremybenn
/* simple-object-elf.c -- routines to manipulate ELF object files.
2
   Copyright 2010 Free Software Foundation, Inc.
3
   Written by Ian Lance Taylor, Google.
4
 
5
This program is free software; you can redistribute it and/or modify it
6
under the terms of the GNU General Public License as published by the
7
Free Software Foundation; either version 2, or (at your option) any
8
later version.
9
 
10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU General Public License for more details.
14
 
15
You should have received a copy of the GNU General Public License
16
along with this program; if not, write to the Free Software
17
Foundation, 51 Franklin Street - Fifth Floor,
18
Boston, MA 02110-1301, USA.  */
19
 
20
#include "config.h"
21
#include "libiberty.h"
22
#include "simple-object.h"
23
 
24
#include <errno.h>
25
#include <stddef.h>
26
 
27
#ifdef HAVE_STDLIB_H
28
#include <stdlib.h>
29
#endif
30
 
31
#ifdef HAVE_STDINT_H
32
#include <stdint.h>
33
#endif
34
 
35
#ifdef HAVE_STRING_H
36
#include <string.h>
37
#endif
38
 
39
#ifdef HAVE_INTTYPES_H
40
#include <inttypes.h>
41
#endif
42
 
43
#include "simple-object-common.h"
44
 
45
/* ELF structures and constants.  */
46
 
47
/* 32-bit ELF file header.  */
48
 
49
typedef struct {
50
  unsigned char e_ident[16];            /* ELF "magic number" */
51
  unsigned char e_type[2];              /* Identifies object file type */
52
  unsigned char e_machine[2];           /* Specifies required architecture */
53
  unsigned char e_version[4];           /* Identifies object file version */
54
  unsigned char e_entry[4];             /* Entry point virtual address */
55
  unsigned char e_phoff[4];             /* Program header table file offset */
56
  unsigned char e_shoff[4];             /* Section header table file offset */
57
  unsigned char e_flags[4];             /* Processor-specific flags */
58
  unsigned char e_ehsize[2];            /* ELF header size in bytes */
59
  unsigned char e_phentsize[2];         /* Program header table entry size */
60
  unsigned char e_phnum[2];             /* Program header table entry count */
61
  unsigned char e_shentsize[2];         /* Section header table entry size */
62
  unsigned char e_shnum[2];             /* Section header table entry count */
63
  unsigned char e_shstrndx[2];          /* Section header string table index */
64
} Elf32_External_Ehdr;
65
 
66
/* 64-bit ELF file header.  */
67
 
68
typedef struct {
69
  unsigned char e_ident[16];            /* ELF "magic number" */
70
  unsigned char e_type[2];              /* Identifies object file type */
71
  unsigned char e_machine[2];           /* Specifies required architecture */
72
  unsigned char e_version[4];           /* Identifies object file version */
73
  unsigned char e_entry[8];             /* Entry point virtual address */
74
  unsigned char e_phoff[8];             /* Program header table file offset */
75
  unsigned char e_shoff[8];             /* Section header table file offset */
76
  unsigned char e_flags[4];             /* Processor-specific flags */
77
  unsigned char e_ehsize[2];            /* ELF header size in bytes */
78
  unsigned char e_phentsize[2];         /* Program header table entry size */
79
  unsigned char e_phnum[2];             /* Program header table entry count */
80
  unsigned char e_shentsize[2];         /* Section header table entry size */
81
  unsigned char e_shnum[2];             /* Section header table entry count */
82
  unsigned char e_shstrndx[2];          /* Section header string table index */
83
} Elf64_External_Ehdr;
84
 
85
/* Indexes and values in e_ident field of Ehdr.  */
86
 
87
#define EI_MAG0         0        /* File identification byte 0 index */
88
#define ELFMAG0            0x7F /* Magic number byte 0 */
89
 
90
#define EI_MAG1         1       /* File identification byte 1 index */
91
#define ELFMAG1             'E' /* Magic number byte 1 */
92
 
93
#define EI_MAG2         2       /* File identification byte 2 index */
94
#define ELFMAG2             'L' /* Magic number byte 2 */
95
 
96
#define EI_MAG3         3       /* File identification byte 3 index */
97
#define ELFMAG3             'F' /* Magic number byte 3 */
98
 
99
#define EI_CLASS        4       /* File class */
100
#define ELFCLASSNONE          0 /* Invalid class */
101
#define ELFCLASS32            1 /* 32-bit objects */
102
#define ELFCLASS64            2 /* 64-bit objects */
103
 
104
#define EI_DATA         5       /* Data encoding */
105
#define ELFDATANONE           0 /* Invalid data encoding */
106
#define ELFDATA2LSB           1 /* 2's complement, little endian */
107
#define ELFDATA2MSB           2 /* 2's complement, big endian */
108
 
109
#define EI_VERSION      6       /* File version */
110
#define EV_CURRENT      1               /* Current version */
111
 
112
#define EI_OSABI        7       /* Operating System/ABI indication */
113
 
114
/* Values for e_type field of Ehdr.  */
115
 
116
#define ET_REL          1       /* Relocatable file */
117
 
118
/* Values for e_machine field of Ehdr.  */
119
 
120
#define EM_SPARC          2     /* SUN SPARC */
121
#define EM_SPARC32PLUS   18     /* Sun's "v8plus" */
122
 
123
/* Special section index values.  */
124
 
125
#define SHN_LORESERVE   0xFF00          /* Begin range of reserved indices */
126
#define SHN_XINDEX      0xFFFF          /* Section index is held elsewhere */
127
 
128
/* 32-bit ELF program header.  */
129
 
130
typedef struct {
131
  unsigned char p_type[4];              /* Identifies program segment type */
132
  unsigned char p_offset[4];            /* Segment file offset */
133
  unsigned char p_vaddr[4];             /* Segment virtual address */
134
  unsigned char p_paddr[4];             /* Segment physical address */
135
  unsigned char p_filesz[4];            /* Segment size in file */
136
  unsigned char p_memsz[4];             /* Segment size in memory */
137
  unsigned char p_flags[4];             /* Segment flags */
138
  unsigned char p_align[4];             /* Segment alignment, file & memory */
139
} Elf32_External_Phdr;
140
 
141
/* 64-bit ELF program header.  */
142
 
143
typedef struct {
144
  unsigned char p_type[4];              /* Identifies program segment type */
145
  unsigned char p_flags[4];             /* Segment flags */
146
  unsigned char p_offset[8];            /* Segment file offset */
147
  unsigned char p_vaddr[8];             /* Segment virtual address */
148
  unsigned char p_paddr[8];             /* Segment physical address */
149
  unsigned char p_filesz[8];            /* Segment size in file */
150
  unsigned char p_memsz[8];             /* Segment size in memory */
151
  unsigned char p_align[8];             /* Segment alignment, file & memory */
152
} Elf64_External_Phdr;
153
 
154
/* 32-bit ELF section header */
155
 
156
typedef struct {
157
  unsigned char sh_name[4];             /* Section name, index in string tbl */
158
  unsigned char sh_type[4];             /* Type of section */
159
  unsigned char sh_flags[4];            /* Miscellaneous section attributes */
160
  unsigned char sh_addr[4];             /* Section virtual addr at execution */
161
  unsigned char sh_offset[4];           /* Section file offset */
162
  unsigned char sh_size[4];             /* Size of section in bytes */
163
  unsigned char sh_link[4];             /* Index of another section */
164
  unsigned char sh_info[4];             /* Additional section information */
165
  unsigned char sh_addralign[4];        /* Section alignment */
166
  unsigned char sh_entsize[4];          /* Entry size if section holds table */
167
} Elf32_External_Shdr;
168
 
169
/* 64-bit ELF section header.  */
170
 
171
typedef struct {
172
  unsigned char sh_name[4];             /* Section name, index in string tbl */
173
  unsigned char sh_type[4];             /* Type of section */
174
  unsigned char sh_flags[8];            /* Miscellaneous section attributes */
175
  unsigned char sh_addr[8];             /* Section virtual addr at execution */
176
  unsigned char sh_offset[8];           /* Section file offset */
177
  unsigned char sh_size[8];             /* Size of section in bytes */
178
  unsigned char sh_link[4];             /* Index of another section */
179
  unsigned char sh_info[4];             /* Additional section information */
180
  unsigned char sh_addralign[8];        /* Section alignment */
181
  unsigned char sh_entsize[8];          /* Entry size if section holds table */
182
} Elf64_External_Shdr;
183
 
184
/* Values for sh_type field.  */
185
 
186
#define SHT_PROGBITS    1               /* Program data */
187
#define SHT_STRTAB      3               /* A string table */
188
 
189
/* Functions to fetch and store different ELF types, depending on the
190
   endianness and size.  */
191
 
192
struct elf_type_functions
193
{
194
  unsigned short (*fetch_Elf_Half) (const unsigned char *);
195
  unsigned int (*fetch_Elf_Word) (const unsigned char *);
196
  ulong_type (*fetch_Elf_Addr) (const unsigned char *);
197
  void (*set_Elf_Half) (unsigned char *, unsigned short);
198
  void (*set_Elf_Word) (unsigned char *, unsigned int);
199
  void (*set_Elf_Addr) (unsigned char *, ulong_type);
200
};
201
 
202
static const struct elf_type_functions elf_big_32_functions =
203
{
204
  simple_object_fetch_big_16,
205
  simple_object_fetch_big_32,
206
  simple_object_fetch_big_32_ulong,
207
  simple_object_set_big_16,
208
  simple_object_set_big_32,
209
  simple_object_set_big_32_ulong
210
};
211
 
212
static const struct elf_type_functions elf_little_32_functions =
213
{
214
  simple_object_fetch_little_16,
215
  simple_object_fetch_little_32,
216
  simple_object_fetch_little_32_ulong,
217
  simple_object_set_little_16,
218
  simple_object_set_little_32,
219
  simple_object_set_little_32_ulong
220
};
221
 
222
#ifdef UNSIGNED_64BIT_TYPE
223
 
224
static const struct elf_type_functions elf_big_64_functions =
225
{
226
  simple_object_fetch_big_16,
227
  simple_object_fetch_big_32,
228
  simple_object_fetch_big_64,
229
  simple_object_set_big_16,
230
  simple_object_set_big_32,
231
  simple_object_set_big_64
232
};
233
 
234
static const struct elf_type_functions elf_little_64_functions =
235
{
236
  simple_object_fetch_little_16,
237
  simple_object_fetch_little_32,
238
  simple_object_fetch_little_64,
239
  simple_object_set_little_16,
240
  simple_object_set_little_32,
241
  simple_object_set_little_64
242
};
243
 
244
#endif
245
 
246
/* Hideous macro to fetch the value of a field from an external ELF
247
   struct of some sort.  TYPEFUNCS is the set of type functions.
248
   BUFFER points to the external data.  STRUCTTYPE is the appropriate
249
   struct type.  FIELD is a field within the struct.  TYPE is the type
250
   of the field in the struct: Elf_Half, Elf_Word, or Elf_Addr.  */
251
 
252
#define ELF_FETCH_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE) \
253
  ((TYPEFUNCS)->fetch_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD)))
254
 
255
/* Even more hideous macro to fetch the value of FIELD from BUFFER.
256
   SIZE is 32 or 64.  STRUCTTYPE is the name of the struct from
257
   elf/external.h: Ehdr, Shdr, etc.  FIELD is the name of a field in
258
   the struct.  TYPE is the type of the field in the struct: Elf_Half,
259
   Elf_Word, or Elf_Addr.  */
260
 
261
#define ELF_FETCH_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER,      \
262
                              FIELD, TYPE)                              \
263
  ELF_FETCH_STRUCT_FIELD (TYPEFUNCS,                                    \
264
                          Elf ## SIZE ## _External_ ## STRUCTTYPE,      \
265
                          FIELD, BUFFER, TYPE)
266
 
267
/* Like ELF_FETCH_SIZED_FIELD but taking an ELFCLASS value.  */
268
 
269
#define ELF_FETCH_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER,           \
270
                        FIELD, TYPE)                                    \
271
  ((CLASS) == ELFCLASS32                                                \
272
    ? ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD,  \
273
                             TYPE)                                      \
274
    : ELF_FETCH_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD,  \
275
                             TYPE))
276
 
277
/* Hideous macro to set the value of a field in an external ELF
278
   structure to VAL.  TYPEFUNCS is the set of type functions.  BUFFER
279
   points to the external data.  STRUCTTYPE is the appropriate
280
   structure type.  FIELD is a field within the struct.  TYPE is the
281
   type of the field in the struct: Elf_Half, Elf_Word, or
282
   Elf_Addr.  */
283
 
284
#define ELF_SET_STRUCT_FIELD(TYPEFUNCS, STRUCTTYPE, FIELD, BUFFER, TYPE, VAL) \
285
  (TYPEFUNCS)->set_ ## TYPE ((BUFFER) + offsetof (STRUCTTYPE, FIELD), (VAL))
286
 
287
/* Even more hideous macro to set the value of FIELD in BUFFER to VAL.
288
   SIZE is 32 or 64.  STRUCTTYPE is the name of the struct from
289
   elf/external.h: Ehdr, Shdr, etc.  FIELD is the name of a field in
290
   the struct.  TYPE is the type of the field in the struct: Elf_Half,
291
   Elf_Word, or Elf_Addr.  */
292
 
293
#define ELF_SET_SIZED_FIELD(TYPEFUNCS, SIZE, STRUCTTYPE, BUFFER, FIELD, \
294
                            TYPE, VAL)                                  \
295
  ELF_SET_STRUCT_FIELD (TYPEFUNCS,                                      \
296
                        Elf ## SIZE ## _External_ ## STRUCTTYPE,        \
297
                        FIELD, BUFFER, TYPE, VAL)
298
 
299
/* Like ELF_SET_SIZED_FIELD but taking an ELFCLASS value.  */
300
 
301
#define ELF_SET_FIELD(TYPEFUNCS, CLASS, STRUCTTYPE, BUFFER, FIELD,      \
302
                      TYPE, VAL)                                        \
303
  ((CLASS) == ELFCLASS32                                                \
304
    ? ELF_SET_SIZED_FIELD (TYPEFUNCS, 32, STRUCTTYPE, BUFFER, FIELD,    \
305
                           TYPE, VAL)                                   \
306
    : ELF_SET_SIZED_FIELD (TYPEFUNCS, 64, STRUCTTYPE, BUFFER, FIELD,    \
307
                           TYPE, VAL))
308
 
309
/* Private data for an simple_object_read.  */
310
 
311
struct simple_object_elf_read
312
{
313
  /* Type functions.  */
314
  const struct elf_type_functions* type_functions;
315
  /* Elf data.  */
316
  unsigned char ei_data;
317
  /* Elf class.  */
318
  unsigned char ei_class;
319
  /* ELF OS ABI.  */
320
  unsigned char ei_osabi;
321
  /* Elf machine number.  */
322
  unsigned short machine;
323
  /* Processor specific flags.  */
324
  unsigned int flags;
325
  /* File offset of section headers.  */
326
  ulong_type shoff;
327
  /* Number of sections.  */
328
  unsigned int shnum;
329
  /* Index of string table section header.  */
330
  unsigned int shstrndx;
331
};
332
 
333
/* Private data for an simple_object_attributes.  */
334
 
335
struct simple_object_elf_attributes
336
{
337
  /* Type functions.  */
338
  const struct elf_type_functions* type_functions;
339
  /* Elf data.  */
340
  unsigned char ei_data;
341
  /* Elf class.  */
342
  unsigned char ei_class;
343
  /* ELF OS ABI.  */
344
  unsigned char ei_osabi;
345
  /* Elf machine number.  */
346
  unsigned short machine;
347
  /* Processor specific flags.  */
348
  unsigned int flags;
349
};
350
 
351
/* See if we have an ELF file.  */
352
 
353
static void *
354
simple_object_elf_match (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
355
                         int descriptor, off_t offset,
356
                         const char *segment_name ATTRIBUTE_UNUSED,
357
                         const char **errmsg, int *err)
358
{
359
  unsigned char ei_data;
360
  unsigned char ei_class;
361
  const struct elf_type_functions *type_functions;
362
  unsigned char ehdr[sizeof (Elf64_External_Ehdr)];
363
  struct simple_object_elf_read *eor;
364
 
365
  if (header[EI_MAG0] != ELFMAG0
366
      || header[EI_MAG1] != ELFMAG1
367
      || header[EI_MAG2] != ELFMAG2
368
      || header[EI_MAG3] != ELFMAG3
369
      || header[EI_VERSION] != EV_CURRENT)
370
    {
371
      *errmsg = NULL;
372
      *err = 0;
373
      return NULL;
374
    }
375
 
376
  ei_data = header[EI_DATA];
377
  if (ei_data != ELFDATA2LSB && ei_data != ELFDATA2MSB)
378
    {
379
      *errmsg = "unknown ELF endianness";
380
      *err = 0;
381
      return NULL;
382
    }
383
 
384
  ei_class = header[EI_CLASS];
385
  switch (ei_class)
386
    {
387
    case ELFCLASS32:
388
      type_functions = (ei_data == ELFDATA2LSB
389
                        ? &elf_little_32_functions
390
                        : &elf_big_32_functions);
391
      break;
392
 
393
    case ELFCLASS64:
394
#ifndef UNSIGNED_64BIT_TYPE
395
      *errmsg = "64-bit ELF objects not supported";
396
      *err = 0;
397
      return NULL;
398
#else
399
      type_functions = (ei_data == ELFDATA2LSB
400
                        ? &elf_little_64_functions
401
                        : &elf_big_64_functions);
402
      break;
403
#endif
404
 
405
    default:
406
      *errmsg = "unrecognized ELF size";
407
      *err = 0;
408
      return NULL;
409
    }
410
 
411
  if (!simple_object_internal_read (descriptor, offset, ehdr, sizeof ehdr,
412
                                    errmsg, err))
413
    return NULL;
414
 
415
  eor = XNEW (struct simple_object_elf_read);
416
  eor->type_functions = type_functions;
417
  eor->ei_data = ei_data;
418
  eor->ei_class = ei_class;
419
  eor->ei_osabi = header[EI_OSABI];
420
  eor->machine = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
421
                                  e_machine, Elf_Half);
422
  eor->flags = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
423
                                e_flags, Elf_Word);
424
  eor->shoff = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
425
                                e_shoff, Elf_Addr);
426
  eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
427
                                e_shnum, Elf_Half);
428
  eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Ehdr, ehdr,
429
                                   e_shstrndx, Elf_Half);
430
 
431
  if ((eor->shnum == 0 || eor->shstrndx == SHN_XINDEX)
432
      && eor->shoff != 0)
433
    {
434
      unsigned char shdr[sizeof (Elf64_External_Shdr)];
435
 
436
      /* Object file has more than 0xffff sections.  */
437
 
438
      if (!simple_object_internal_read (descriptor, offset + eor->shoff, shdr,
439
                                        (ei_class == ELFCLASS32
440
                                         ? sizeof (Elf32_External_Shdr)
441
                                         : sizeof (Elf64_External_Shdr)),
442
                                        errmsg, err))
443
        {
444
          XDELETE (eor);
445
          return NULL;
446
        }
447
 
448
      if (eor->shnum == 0)
449
        eor->shnum = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
450
                                      shdr, sh_size, Elf_Addr);
451
 
452
      if (eor->shstrndx == SHN_XINDEX)
453
        {
454
          eor->shstrndx = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
455
                                           shdr, sh_link, Elf_Word);
456
 
457
          /* Versions of the GNU binutils between 2.12 and 2.18 did
458
             not handle objects with more than SHN_LORESERVE sections
459
             correctly.  All large section indexes were offset by
460
             0x100.  There is more information at
461
             http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
462
             Fortunately these object files are easy to detect, as the
463
             GNU binutils always put the section header string table
464
             near the end of the list of sections.  Thus if the
465
             section header string table index is larger than the
466
             number of sections, then we know we have to subtract
467
             0x100 to get the real section index.  */
468
          if (eor->shstrndx >= eor->shnum
469
              && eor->shstrndx >= SHN_LORESERVE + 0x100)
470
            eor->shstrndx -= 0x100;
471
        }
472
    }
473
 
474
  if (eor->shstrndx >= eor->shnum)
475
    {
476
      *errmsg = "invalid ELF shstrndx >= shnum";
477
      *err = 0;
478
      XDELETE (eor);
479
      return NULL;
480
    }
481
 
482
  return (void *) eor;
483
}
484
 
485
/* Find all sections in an ELF file.  */
486
 
487
static const char *
488
simple_object_elf_find_sections (simple_object_read *sobj,
489
                                 int (*pfn) (void *, const char *,
490
                                             off_t offset, off_t length),
491
                                 void *data,
492
                                 int *err)
493
{
494
  struct simple_object_elf_read *eor =
495
    (struct simple_object_elf_read *) sobj->data;
496
  const struct elf_type_functions *type_functions = eor->type_functions;
497
  unsigned char ei_class = eor->ei_class;
498
  size_t shdr_size;
499
  unsigned int shnum;
500
  unsigned char *shdrs;
501
  const char *errmsg;
502
  unsigned char *shstrhdr;
503
  size_t name_size;
504
  off_t shstroff;
505
  unsigned char *names;
506
  unsigned int i;
507
 
508
  shdr_size = (ei_class == ELFCLASS32
509
               ? sizeof (Elf32_External_Shdr)
510
               : sizeof (Elf64_External_Shdr));
511
 
512
  /* Read the section headers.  We skip section 0, which is not a
513
     useful section.  */
514
 
515
  shnum = eor->shnum;
516
  shdrs = XNEWVEC (unsigned char, shdr_size * (shnum - 1));
517
 
518
  if (!simple_object_internal_read (sobj->descriptor,
519
                                    sobj->offset + eor->shoff + shdr_size,
520
                                    shdrs,
521
                                    shdr_size * (shnum - 1),
522
                                    &errmsg, err))
523
    {
524
      XDELETEVEC (shdrs);
525
      return errmsg;
526
    }
527
 
528
  /* Read the section names.  */
529
 
530
  shstrhdr = shdrs + (eor->shstrndx - 1) * shdr_size;
531
  name_size = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
532
                               shstrhdr, sh_size, Elf_Addr);
533
  shstroff = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
534
                              shstrhdr, sh_offset, Elf_Addr);
535
  names = XNEWVEC (unsigned char, name_size);
536
  if (!simple_object_internal_read (sobj->descriptor,
537
                                    sobj->offset + shstroff,
538
                                    names, name_size, &errmsg, err))
539
    {
540
      XDELETEVEC (names);
541
      XDELETEVEC (shdrs);
542
      return errmsg;
543
    }
544
 
545
  for (i = 1; i < shnum; ++i)
546
    {
547
      unsigned char *shdr;
548
      unsigned int sh_name;
549
      const char *name;
550
      off_t offset;
551
      off_t length;
552
 
553
      shdr = shdrs + (i - 1) * shdr_size;
554
      sh_name = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
555
                                 shdr, sh_name, Elf_Word);
556
      if (sh_name >= name_size)
557
        {
558
          *err = 0;
559
          XDELETEVEC (names);
560
          XDELETEVEC (shdrs);
561
          return "ELF section name out of range";
562
        }
563
 
564
      name = (const char *) names + sh_name;
565
      offset = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
566
                                shdr, sh_offset, Elf_Addr);
567
      length = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
568
                                shdr, sh_size, Elf_Addr);
569
 
570
      if (!(*pfn) (data, name, offset, length))
571
        break;
572
    }
573
 
574
  XDELETEVEC (names);
575
  XDELETEVEC (shdrs);
576
 
577
  return NULL;
578
}
579
 
580
/* Fetch the attributes for an simple_object_read.  */
581
 
582
static void *
583
simple_object_elf_fetch_attributes (simple_object_read *sobj,
584
                                    const char **errmsg ATTRIBUTE_UNUSED,
585
                                    int *err ATTRIBUTE_UNUSED)
586
{
587
  struct simple_object_elf_read *eor =
588
    (struct simple_object_elf_read *) sobj->data;
589
  struct simple_object_elf_attributes *ret;
590
 
591
  ret = XNEW (struct simple_object_elf_attributes);
592
  ret->type_functions = eor->type_functions;
593
  ret->ei_data = eor->ei_data;
594
  ret->ei_class = eor->ei_class;
595
  ret->ei_osabi = eor->ei_osabi;
596
  ret->machine = eor->machine;
597
  ret->flags = eor->flags;
598
  return ret;
599
}
600
 
601
/* Release the privata data for an simple_object_read.  */
602
 
603
static void
604
simple_object_elf_release_read (void *data)
605
{
606
  XDELETE (data);
607
}
608
 
609
/* Compare two attributes structures.  */
610
 
611
static const char *
612
simple_object_elf_attributes_merge (void *todata, void *fromdata, int *err)
613
{
614
  struct simple_object_elf_attributes *to =
615
    (struct simple_object_elf_attributes *) todata;
616
  struct simple_object_elf_attributes *from =
617
    (struct simple_object_elf_attributes *) fromdata;
618
 
619
  if (to->ei_data != from->ei_data || to->ei_class != from->ei_class)
620
    {
621
      *err = 0;
622
      return "ELF object format mismatch";
623
    }
624
 
625
  if (to->machine != from->machine)
626
    {
627
      int ok;
628
 
629
      /* EM_SPARC and EM_SPARC32PLUS are compatible and force an
630
         output of EM_SPARC32PLUS.  */
631
      ok = 0;
632
      switch (to->machine)
633
        {
634
        case EM_SPARC:
635
          if (from->machine == EM_SPARC32PLUS)
636
            {
637
              to->machine = from->machine;
638
              ok = 1;
639
            }
640
          break;
641
 
642
        case EM_SPARC32PLUS:
643
          if (from->machine == EM_SPARC)
644
            ok = 1;
645
          break;
646
 
647
        default:
648
          break;
649
        }
650
 
651
      if (!ok)
652
        {
653
          *err = 0;
654
          return "ELF machine number mismatch";
655
        }
656
    }
657
 
658
  return NULL;
659
}
660
 
661
/* Release the private data for an attributes structure.  */
662
 
663
static void
664
simple_object_elf_release_attributes (void *data)
665
{
666
  XDELETE (data);
667
}
668
 
669
/* Prepare to write out a file.  */
670
 
671
static void *
672
simple_object_elf_start_write (void *attributes_data,
673
                               const char **errmsg ATTRIBUTE_UNUSED,
674
                               int *err ATTRIBUTE_UNUSED)
675
{
676
  struct simple_object_elf_attributes *attrs =
677
    (struct simple_object_elf_attributes *) attributes_data;
678
  struct simple_object_elf_attributes *ret;
679
 
680
  /* We're just going to record the attributes, but we need to make a
681
     copy because the user may delete them.  */
682
  ret = XNEW (struct simple_object_elf_attributes);
683
  *ret = *attrs;
684
  return ret;
685
}
686
 
687
/* Write out an ELF ehdr.  */
688
 
689
static int
690
simple_object_elf_write_ehdr (simple_object_write *sobj, int descriptor,
691
                              const char **errmsg, int *err)
692
{
693
  struct simple_object_elf_attributes *attrs =
694
    (struct simple_object_elf_attributes *) sobj->data;
695
  const struct elf_type_functions* fns;
696
  unsigned char cl;
697
  size_t ehdr_size;
698
  unsigned char buf[sizeof (Elf64_External_Ehdr)];
699
  simple_object_write_section *section;
700
  unsigned int shnum;
701
 
702
  fns = attrs->type_functions;
703
  cl = attrs->ei_class;
704
 
705
  shnum = 0;
706
  for (section = sobj->sections; section != NULL; section = section->next)
707
    ++shnum;
708
  if (shnum > 0)
709
    {
710
      /* Add a section header for the dummy section and one for
711
         .shstrtab.  */
712
      shnum += 2;
713
    }
714
 
715
  ehdr_size = (cl == ELFCLASS32
716
               ? sizeof (Elf32_External_Ehdr)
717
               : sizeof (Elf64_External_Ehdr));
718
  memset (buf, 0, sizeof (Elf64_External_Ehdr));
719
 
720
  buf[EI_MAG0] = ELFMAG0;
721
  buf[EI_MAG1] = ELFMAG1;
722
  buf[EI_MAG2] = ELFMAG2;
723
  buf[EI_MAG3] = ELFMAG3;
724
  buf[EI_CLASS] = cl;
725
  buf[EI_DATA] = attrs->ei_data;
726
  buf[EI_VERSION] = EV_CURRENT;
727
  buf[EI_OSABI] = attrs->ei_osabi;
728
 
729
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_type, Elf_Half, ET_REL);
730
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_machine, Elf_Half, attrs->machine);
731
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_version, Elf_Word, EV_CURRENT);
732
  /* e_entry left as zero.  */
733
  /* e_phoff left as zero.  */
734
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shoff, Elf_Addr, ehdr_size);
735
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_flags, Elf_Word, attrs->flags);
736
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_ehsize, Elf_Half, ehdr_size);
737
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_phentsize, Elf_Half,
738
                 (cl == ELFCLASS32
739
                  ? sizeof (Elf32_External_Phdr)
740
                  : sizeof (Elf64_External_Phdr)));
741
  /* e_phnum left as zero.  */
742
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shentsize, Elf_Half,
743
                 (cl == ELFCLASS32
744
                  ? sizeof (Elf32_External_Shdr)
745
                  : sizeof (Elf64_External_Shdr)));
746
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shnum, Elf_Half, shnum);
747
  ELF_SET_FIELD (fns, cl, Ehdr, buf, e_shstrndx, Elf_Half,
748
                 shnum == 0 ? 0 : shnum - 1);
749
 
750
  return simple_object_internal_write (descriptor, 0, buf, ehdr_size,
751
                                       errmsg, err);
752
}
753
 
754
/* Write out an ELF shdr.  */
755
 
756
static int
757
simple_object_elf_write_shdr (simple_object_write *sobj, int descriptor,
758
                              off_t offset, unsigned int sh_name,
759
                              unsigned int sh_type, unsigned int sh_flags,
760
                              unsigned int sh_offset, unsigned int sh_size,
761
                              unsigned int sh_addralign, const char **errmsg,
762
                              int *err)
763
{
764
  struct simple_object_elf_attributes *attrs =
765
    (struct simple_object_elf_attributes *) sobj->data;
766
  const struct elf_type_functions* fns;
767
  unsigned char cl;
768
  size_t shdr_size;
769
  unsigned char buf[sizeof (Elf64_External_Shdr)];
770
 
771
  fns = attrs->type_functions;
772
  cl = attrs->ei_class;
773
 
774
  shdr_size = (cl == ELFCLASS32
775
               ? sizeof (Elf32_External_Shdr)
776
               : sizeof (Elf64_External_Shdr));
777
  memset (buf, 0, sizeof (Elf64_External_Shdr));
778
 
779
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_name, Elf_Word, sh_name);
780
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_type, Elf_Word, sh_type);
781
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_flags, Elf_Addr, sh_flags);
782
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_offset, Elf_Addr, sh_offset);
783
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_size, Elf_Addr, sh_size);
784
  /* sh_link left as zero.  */
785
  /* sh_info left as zero.  */
786
  ELF_SET_FIELD (fns, cl, Shdr, buf, sh_addralign, Elf_Addr, sh_addralign);
787
  /* sh_entsize left as zero.  */
788
 
789
  return simple_object_internal_write (descriptor, offset, buf, shdr_size,
790
                                       errmsg, err);
791
}
792
 
793
/* Write out a complete ELF file.
794
   Ehdr
795
   initial dummy Shdr
796
   user-created Shdrs
797
   .shstrtab Shdr
798
   user-created section data
799
   .shstrtab data  */
800
 
801
static const char *
802
simple_object_elf_write_to_file (simple_object_write *sobj, int descriptor,
803
                                 int *err)
804
{
805
  struct simple_object_elf_attributes *attrs =
806
    (struct simple_object_elf_attributes *) sobj->data;
807
  unsigned char cl;
808
  size_t ehdr_size;
809
  size_t shdr_size;
810
  const char *errmsg;
811
  simple_object_write_section *section;
812
  unsigned int shnum;
813
  size_t shdr_offset;
814
  size_t sh_offset;
815
  size_t sh_name;
816
  unsigned char zero;
817
 
818
  if (!simple_object_elf_write_ehdr (sobj, descriptor, &errmsg, err))
819
    return errmsg;
820
 
821
  cl = attrs->ei_class;
822
  if (cl == ELFCLASS32)
823
    {
824
      ehdr_size = sizeof (Elf32_External_Ehdr);
825
      shdr_size = sizeof (Elf32_External_Shdr);
826
    }
827
  else
828
    {
829
      ehdr_size = sizeof (Elf64_External_Ehdr);
830
      shdr_size = sizeof (Elf64_External_Shdr);
831
    }
832
 
833
  shnum = 0;
834
  for (section = sobj->sections; section != NULL; section = section->next)
835
    ++shnum;
836
  if (shnum == 0)
837
    return NULL;
838
 
839
  /* Add initial dummy Shdr and .shstrtab.  */
840
  shnum += 2;
841
 
842
  shdr_offset = ehdr_size;
843
  sh_offset = shdr_offset + shnum * shdr_size;
844
 
845
  if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
846
                                     0, 0, 0, 0, 0, 0, &errmsg, err))
847
    return errmsg;
848
 
849
  shdr_offset += shdr_size;
850
 
851
  sh_name = 1;
852
  for (section = sobj->sections; section != NULL; section = section->next)
853
    {
854
      size_t mask;
855
      size_t new_sh_offset;
856
      size_t sh_size;
857
      struct simple_object_write_section_buffer *buffer;
858
 
859
      mask = (1U << section->align) - 1;
860
      new_sh_offset = sh_offset + mask;
861
      new_sh_offset &= ~ mask;
862
      while (new_sh_offset > sh_offset)
863
        {
864
          unsigned char zeroes[16];
865
          size_t write;
866
 
867
          memset (zeroes, 0, sizeof zeroes);
868
          write = new_sh_offset - sh_offset;
869
          if (write > sizeof zeroes)
870
            write = sizeof zeroes;
871
          if (!simple_object_internal_write (descriptor, sh_offset, zeroes,
872
                                             write, &errmsg, err))
873
            return errmsg;
874
          sh_offset += write;
875
        }
876
 
877
      sh_size = 0;
878
      for (buffer = section->buffers; buffer != NULL; buffer = buffer->next)
879
        {
880
          if (!simple_object_internal_write (descriptor, sh_offset + sh_size,
881
                                             ((const unsigned char *)
882
                                              buffer->buffer),
883
                                             buffer->size, &errmsg, err))
884
            return errmsg;
885
          sh_size += buffer->size;
886
        }
887
 
888
      if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
889
                                         sh_name, SHT_PROGBITS, 0, sh_offset,
890
                                         sh_size, 1U << section->align,
891
                                         &errmsg, err))
892
        return errmsg;
893
 
894
      shdr_offset += shdr_size;
895
      sh_name += strlen (section->name) + 1;
896
      sh_offset += sh_size;
897
    }
898
 
899
  if (!simple_object_elf_write_shdr (sobj, descriptor, shdr_offset,
900
                                     sh_name, SHT_STRTAB, 0, sh_offset,
901
                                     sh_name + strlen (".shstrtab") + 1,
902
                                     1, &errmsg, err))
903
    return errmsg;
904
 
905
  /* .shstrtab has a leading zero byte.  */
906
  zero = 0;
907
  if (!simple_object_internal_write (descriptor, sh_offset, &zero, 1,
908
                                     &errmsg, err))
909
    return errmsg;
910
  ++sh_offset;
911
 
912
  for (section = sobj->sections; section != NULL; section = section->next)
913
    {
914
      size_t len;
915
 
916
      len = strlen (section->name) + 1;
917
      if (!simple_object_internal_write (descriptor, sh_offset,
918
                                         (const unsigned char *) section->name,
919
                                         len, &errmsg, err))
920
        return errmsg;
921
      sh_offset += len;
922
    }
923
 
924
  if (!simple_object_internal_write (descriptor, sh_offset,
925
                                     (const unsigned char *) ".shstrtab",
926
                                     strlen (".shstrtab") + 1, &errmsg, err))
927
    return errmsg;
928
 
929
  return NULL;
930
}
931
 
932
/* Release the private data for an simple_object_write structure.  */
933
 
934
static void
935
simple_object_elf_release_write (void *data)
936
{
937
  XDELETE (data);
938
}
939
 
940
/* The ELF functions.  */
941
 
942
const struct simple_object_functions simple_object_elf_functions =
943
{
944
  simple_object_elf_match,
945
  simple_object_elf_find_sections,
946
  simple_object_elf_fetch_attributes,
947
  simple_object_elf_release_read,
948
  simple_object_elf_attributes_merge,
949
  simple_object_elf_release_attributes,
950
  simple_object_elf_start_write,
951
  simple_object_elf_write_to_file,
952
  simple_object_elf_release_write
953
};

powered by: WebSVN 2.1.0

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