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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [opncls.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* opncls.c -- open and close a BFD.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
3
   2001, 2002, 2003, 2004, 2005, 2006, 2007
4
   Free Software Foundation, Inc.
5
 
6
   Written by Cygnus Support.
7
 
8
   This file is part of BFD, the Binary File Descriptor library.
9
 
10
   This program is free software; you can redistribute it and/or modify
11
   it under the terms of the GNU General Public License as published by
12
   the Free Software Foundation; either version 3 of the License, or
13
   (at your option) any later version.
14
 
15
   This program is distributed in the hope that it will be useful,
16
   but WITHOUT ANY WARRANTY; without even the implied warranty of
17
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
   GNU General Public License for more details.
19
 
20
   You should have received a copy of the GNU General Public License
21
   along with this program; if not, write to the Free Software
22
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23
   MA 02110-1301, USA.  */
24
 
25
#include "sysdep.h"
26
#include "bfd.h"
27
#include "objalloc.h"
28
#include "libbfd.h"
29
#include "libiberty.h"
30
 
31
#ifndef S_IXUSR
32
#define S_IXUSR 0100    /* Execute by owner.  */
33
#endif
34
#ifndef S_IXGRP
35
#define S_IXGRP 0010    /* Execute by group.  */
36
#endif
37
#ifndef S_IXOTH
38
#define S_IXOTH 0001    /* Execute by others.  */
39
#endif
40
 
41
/* Counter used to initialize the bfd identifier.  */
42
 
43
static unsigned int _bfd_id_counter = 0;
44
 
45
/* fdopen is a loser -- we should use stdio exclusively.  Unfortunately
46
   if we do that we can't use fcntl.  */
47
 
48
/* Return a new BFD.  All BFD's are allocated through this routine.  */
49
 
50
bfd *
51
_bfd_new_bfd (void)
52
{
53
  bfd *nbfd;
54
 
55
  nbfd = bfd_zmalloc (sizeof (bfd));
56
  if (nbfd == NULL)
57
    return NULL;
58
 
59
  nbfd->id = _bfd_id_counter++;
60
 
61
  nbfd->memory = objalloc_create ();
62
  if (nbfd->memory == NULL)
63
    {
64
      bfd_set_error (bfd_error_no_memory);
65
      free (nbfd);
66
      return NULL;
67
    }
68
 
69
  nbfd->arch_info = &bfd_default_arch_struct;
70
 
71
  nbfd->direction = no_direction;
72
  nbfd->iostream = NULL;
73
  nbfd->where = 0;
74
  if (!bfd_hash_table_init_n (& nbfd->section_htab, bfd_section_hash_newfunc,
75
                              sizeof (struct section_hash_entry), 251))
76
    {
77
      free (nbfd);
78
      return NULL;
79
    }
80
  nbfd->sections = NULL;
81
  nbfd->section_last = NULL;
82
  nbfd->format = bfd_unknown;
83
  nbfd->my_archive = NULL;
84
  nbfd->origin = 0;
85
  nbfd->opened_once = FALSE;
86
  nbfd->output_has_begun = FALSE;
87
  nbfd->section_count = 0;
88
  nbfd->usrdata = NULL;
89
  nbfd->cacheable = FALSE;
90
  nbfd->flags = BFD_NO_FLAGS;
91
  nbfd->mtime_set = FALSE;
92
 
93
  return nbfd;
94
}
95
 
96
/* Allocate a new BFD as a member of archive OBFD.  */
97
 
98
bfd *
99
_bfd_new_bfd_contained_in (bfd *obfd)
100
{
101
  bfd *nbfd;
102
 
103
  nbfd = _bfd_new_bfd ();
104
  if (nbfd == NULL)
105
    return NULL;
106
  nbfd->xvec = obfd->xvec;
107
  nbfd->iovec = obfd->iovec;
108
  nbfd->my_archive = obfd;
109
  nbfd->direction = read_direction;
110
  nbfd->target_defaulted = obfd->target_defaulted;
111
  return nbfd;
112
}
113
 
114
/* Delete a BFD.  */
115
 
116
void
117
_bfd_delete_bfd (bfd *abfd)
118
{
119
  if (abfd->memory)
120
    {
121
      bfd_hash_table_free (&abfd->section_htab);
122
      objalloc_free ((struct objalloc *) abfd->memory);
123
    }
124
  free (abfd);
125
}
126
 
127
/* Free objalloc memory.  */
128
 
129
bfd_boolean
130
_bfd_free_cached_info (bfd *abfd)
131
{
132
  if (abfd->memory)
133
    {
134
      bfd_hash_table_free (&abfd->section_htab);
135
      objalloc_free ((struct objalloc *) abfd->memory);
136
 
137
      abfd->sections = NULL;
138
      abfd->section_last = NULL;
139
      abfd->outsymbols = NULL;
140
      abfd->tdata.any = NULL;
141
      abfd->usrdata = NULL;
142
      abfd->memory = NULL;
143
    }
144
 
145
  return TRUE;
146
}
147
 
148
/*
149
SECTION
150
        Opening and closing BFDs
151
 
152
SUBSECTION
153
        Functions for opening and closing
154
*/
155
 
156
/*
157
FUNCTION
158
        bfd_fopen
159
 
160
SYNOPSIS
161
        bfd *bfd_fopen (const char *filename, const char *target,
162
                        const char *mode, int fd);
163
 
164
DESCRIPTION
165
        Open the file @var{filename} with the target @var{target}.
166
        Return a pointer to the created BFD.  If @var{fd} is not -1,
167
        then <<fdopen>> is used to open the file; otherwise, <<fopen>>
168
        is used.  @var{mode} is passed directly to <<fopen>> or
169
        <<fdopen>>.
170
 
171
        Calls <<bfd_find_target>>, so @var{target} is interpreted as by
172
        that function.
173
 
174
        The new BFD is marked as cacheable iff @var{fd} is -1.
175
 
176
        If <<NULL>> is returned then an error has occured.   Possible errors
177
        are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
178
        <<system_call>> error.
179
*/
180
 
181
bfd *
182
bfd_fopen (const char *filename, const char *target, const char *mode, int fd)
183
{
184
  bfd *nbfd;
185
  const bfd_target *target_vec;
186
 
187
  nbfd = _bfd_new_bfd ();
188
  if (nbfd == NULL)
189
    return NULL;
190
 
191
  target_vec = bfd_find_target (target, nbfd);
192
  if (target_vec == NULL)
193
    {
194
      _bfd_delete_bfd (nbfd);
195
      return NULL;
196
    }
197
 
198
#ifdef HAVE_FDOPEN
199
  if (fd != -1)
200
    nbfd->iostream = fdopen (fd, mode);
201
  else
202
#endif
203
    nbfd->iostream = real_fopen (filename, mode);
204
  if (nbfd->iostream == NULL)
205
    {
206
      bfd_set_error (bfd_error_system_call);
207
      _bfd_delete_bfd (nbfd);
208
      return NULL;
209
    }
210
 
211
  /* OK, put everything where it belongs.  */
212
  nbfd->filename = filename;
213
 
214
  /* Figure out whether the user is opening the file for reading,
215
     writing, or both, by looking at the MODE argument.  */
216
  if ((mode[0] == 'r' || mode[0] == 'w' || mode[0] == 'a')
217
      && mode[1] == '+')
218
    nbfd->direction = both_direction;
219
  else if (mode[0] == 'r')
220
    nbfd->direction = read_direction;
221
  else
222
    nbfd->direction = write_direction;
223
 
224
  if (! bfd_cache_init (nbfd))
225
    {
226
      _bfd_delete_bfd (nbfd);
227
      return NULL;
228
    }
229
  nbfd->opened_once = TRUE;
230
  /* If we opened the file by name, mark it cacheable; we can close it
231
     and reopen it later.  However, if a file descriptor was provided,
232
     then it may have been opened with special flags that make it
233
     unsafe to close and reopen the file.  */
234
  if (fd == -1)
235
    bfd_set_cacheable (nbfd, TRUE);
236
 
237
  return nbfd;
238
}
239
 
240
/*
241
FUNCTION
242
        bfd_openr
243
 
244
SYNOPSIS
245
        bfd *bfd_openr (const char *filename, const char *target);
246
 
247
DESCRIPTION
248
        Open the file @var{filename} (using <<fopen>>) with the target
249
        @var{target}.  Return a pointer to the created BFD.
250
 
251
        Calls <<bfd_find_target>>, so @var{target} is interpreted as by
252
        that function.
253
 
254
        If <<NULL>> is returned then an error has occured.   Possible errors
255
        are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or
256
        <<system_call>> error.
257
*/
258
 
259
bfd *
260
bfd_openr (const char *filename, const char *target)
261
{
262
  return bfd_fopen (filename, target, FOPEN_RB, -1);
263
}
264
 
265
/* Don't try to `optimize' this function:
266
 
267
   o - We lock using stack space so that interrupting the locking
268
       won't cause a storage leak.
269
   o - We open the file stream last, since we don't want to have to
270
       close it if anything goes wrong.  Closing the stream means closing
271
       the file descriptor too, even though we didn't open it.  */
272
/*
273
FUNCTION
274
        bfd_fdopenr
275
 
276
SYNOPSIS
277
        bfd *bfd_fdopenr (const char *filename, const char *target, int fd);
278
 
279
DESCRIPTION
280
        <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to
281
        <<fopen>>.  It opens a BFD on a file already described by the
282
        @var{fd} supplied.
283
 
284
        When the file is later <<bfd_close>>d, the file descriptor will
285
        be closed.  If the caller desires that this file descriptor be
286
        cached by BFD (opened as needed, closed as needed to free
287
        descriptors for other opens), with the supplied @var{fd} used as
288
        an initial file descriptor (but subject to closure at any time),
289
        call bfd_set_cacheable(bfd, 1) on the returned BFD.  The default
290
        is to assume no caching; the file descriptor will remain open
291
        until <<bfd_close>>, and will not be affected by BFD operations
292
        on other files.
293
 
294
        Possible errors are <<bfd_error_no_memory>>,
295
        <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
296
*/
297
 
298
bfd *
299
bfd_fdopenr (const char *filename, const char *target, int fd)
300
{
301
  const char *mode;
302
#if defined(HAVE_FCNTL) && defined(F_GETFL)
303
  int fdflags;
304
#endif
305
 
306
#if ! defined(HAVE_FCNTL) || ! defined(F_GETFL)
307
  mode = FOPEN_RUB; /* Assume full access.  */
308
#else
309
  fdflags = fcntl (fd, F_GETFL, NULL);
310
  if (fdflags == -1)
311
    {
312
      bfd_set_error (bfd_error_system_call);
313
      return NULL;
314
    }
315
 
316
  /* (O_ACCMODE) parens are to avoid Ultrix header file bug.  */
317
  switch (fdflags & (O_ACCMODE))
318
    {
319
    case O_RDONLY: mode = FOPEN_RB; break;
320
    case O_WRONLY: mode = FOPEN_RUB; break;
321
    case O_RDWR:   mode = FOPEN_RUB; break;
322
    default: abort ();
323
    }
324
#endif
325
 
326
  return bfd_fopen (filename, target, mode, fd);
327
}
328
 
329
/*
330
FUNCTION
331
        bfd_openstreamr
332
 
333
SYNOPSIS
334
        bfd *bfd_openstreamr (const char *, const char *, void *);
335
 
336
DESCRIPTION
337
 
338
        Open a BFD for read access on an existing stdio stream.  When
339
        the BFD is passed to <<bfd_close>>, the stream will be closed.
340
*/
341
 
342
bfd *
343
bfd_openstreamr (const char *filename, const char *target, void *streamarg)
344
{
345
  FILE *stream = streamarg;
346
  bfd *nbfd;
347
  const bfd_target *target_vec;
348
 
349
  nbfd = _bfd_new_bfd ();
350
  if (nbfd == NULL)
351
    return NULL;
352
 
353
  target_vec = bfd_find_target (target, nbfd);
354
  if (target_vec == NULL)
355
    {
356
      _bfd_delete_bfd (nbfd);
357
      return NULL;
358
    }
359
 
360
  nbfd->iostream = stream;
361
  nbfd->filename = filename;
362
  nbfd->direction = read_direction;
363
 
364
  if (! bfd_cache_init (nbfd))
365
    {
366
      _bfd_delete_bfd (nbfd);
367
      return NULL;
368
    }
369
 
370
  return nbfd;
371
}
372
 
373
/*
374
FUNCTION
375
        bfd_openr_iovec
376
 
377
SYNOPSIS
378
        bfd *bfd_openr_iovec (const char *filename, const char *target,
379
                              void *(*open) (struct bfd *nbfd,
380
                                             void *open_closure),
381
                              void *open_closure,
382
                              file_ptr (*pread) (struct bfd *nbfd,
383
                                                 void *stream,
384
                                                 void *buf,
385
                                                 file_ptr nbytes,
386
                                                 file_ptr offset),
387
                              int (*close) (struct bfd *nbfd,
388
                                            void *stream),
389
                              int (*stat) (struct bfd *abfd,
390
                                           void *stream,
391
                                           struct stat *sb));
392
 
393
DESCRIPTION
394
 
395
        Create and return a BFD backed by a read-only @var{stream}.
396
        The @var{stream} is created using @var{open}, accessed using
397
        @var{pread} and destroyed using @var{close}.
398
 
399
        Calls <<bfd_find_target>>, so @var{target} is interpreted as by
400
        that function.
401
 
402
        Calls @var{open} (which can call <<bfd_zalloc>> and
403
        <<bfd_get_filename>>) to obtain the read-only stream backing
404
        the BFD.  @var{open} either succeeds returning the
405
        non-<<NULL>> @var{stream}, or fails returning <<NULL>>
406
        (setting <<bfd_error>>).
407
 
408
        Calls @var{pread} to request @var{nbytes} of data from
409
        @var{stream} starting at @var{offset} (e.g., via a call to
410
        <<bfd_read>>).  @var{pread} either succeeds returning the
411
        number of bytes read (which can be less than @var{nbytes} when
412
        end-of-file), or fails returning -1 (setting <<bfd_error>>).
413
 
414
        Calls @var{close} when the BFD is later closed using
415
        <<bfd_close>>.  @var{close} either succeeds returning 0, or
416
        fails returning -1 (setting <<bfd_error>>).
417
 
418
        Calls @var{stat} to fill in a stat structure for bfd_stat,
419
        bfd_get_size, and bfd_get_mtime calls.  @var{stat} returns 0
420
        on success, or returns -1 on failure (setting <<bfd_error>>).
421
 
422
        If <<bfd_openr_iovec>> returns <<NULL>> then an error has
423
        occurred.  Possible errors are <<bfd_error_no_memory>>,
424
        <<bfd_error_invalid_target>> and <<bfd_error_system_call>>.
425
 
426
*/
427
 
428
struct opncls
429
{
430
  void *stream;
431
  file_ptr (*pread) (struct bfd *abfd, void *stream, void *buf,
432
                     file_ptr nbytes, file_ptr offset);
433
  int (*close) (struct bfd *abfd, void *stream);
434
  int (*stat) (struct bfd *abfd, void *stream, struct stat *sb);
435
  file_ptr where;
436
};
437
 
438
static file_ptr
439
opncls_btell (struct bfd *abfd)
440
{
441
  struct opncls *vec = abfd->iostream;
442
  return vec->where;
443
}
444
 
445
static int
446
opncls_bseek (struct bfd *abfd, file_ptr offset, int whence)
447
{
448
  struct opncls *vec = abfd->iostream;
449
  switch (whence)
450
    {
451
    case SEEK_SET: vec->where = offset; break;
452
    case SEEK_CUR: vec->where += offset; break;
453
    case SEEK_END: return -1;
454
    }
455
  return 0;
456
}
457
 
458
static file_ptr
459
opncls_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
460
{
461
  struct opncls *vec = abfd->iostream;
462
  file_ptr nread = (vec->pread) (abfd, vec->stream, buf, nbytes, vec->where);
463
  if (nread < 0)
464
    return nread;
465
  vec->where += nread;
466
  return nread;
467
}
468
 
469
static file_ptr
470
opncls_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
471
              const void *where ATTRIBUTE_UNUSED,
472
              file_ptr nbytes ATTRIBUTE_UNUSED)
473
{
474
  return -1;
475
}
476
 
477
static int
478
opncls_bclose (struct bfd *abfd)
479
{
480
  struct opncls *vec = abfd->iostream;
481
  /* Since the VEC's memory is bound to the bfd deleting the bfd will
482
     free it.  */
483
  int status = 0;
484
  if (vec->close != NULL)
485
    status = (vec->close) (abfd, vec->stream);
486
  abfd->iostream = NULL;
487
  return status;
488
}
489
 
490
static int
491
opncls_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
492
{
493
  return 0;
494
}
495
 
496
static int
497
opncls_bstat (struct bfd *abfd, struct stat *sb)
498
{
499
  struct opncls *vec = abfd->iostream;
500
 
501
  memset (sb, 0, sizeof (*sb));
502
  if (vec->stat == NULL)
503
    return 0;
504
 
505
  return (vec->stat) (abfd, vec->stream, sb);
506
}
507
 
508
static const struct bfd_iovec opncls_iovec = {
509
  &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
510
  &opncls_bclose, &opncls_bflush, &opncls_bstat
511
};
512
 
513
bfd *
514
bfd_openr_iovec (const char *filename, const char *target,
515
                 void *(*open) (struct bfd *nbfd,
516
                                void *open_closure),
517
                 void *open_closure,
518
                 file_ptr (*pread) (struct bfd *abfd,
519
                                    void *stream,
520
                                    void *buf,
521
                                    file_ptr nbytes,
522
                                    file_ptr offset),
523
                 int (*close) (struct bfd *nbfd,
524
                               void *stream),
525
                 int (*stat) (struct bfd *abfd,
526
                              void *stream,
527
                              struct stat *sb))
528
{
529
  bfd *nbfd;
530
  const bfd_target *target_vec;
531
  struct opncls *vec;
532
  void *stream;
533
 
534
  nbfd = _bfd_new_bfd ();
535
  if (nbfd == NULL)
536
    return NULL;
537
 
538
  target_vec = bfd_find_target (target, nbfd);
539
  if (target_vec == NULL)
540
    {
541
      _bfd_delete_bfd (nbfd);
542
      return NULL;
543
    }
544
 
545
  nbfd->filename = filename;
546
  nbfd->direction = read_direction;
547
 
548
  /* `open (...)' would get expanded by an the open(2) syscall macro.  */
549
  stream = (*open) (nbfd, open_closure);
550
  if (stream == NULL)
551
    {
552
      _bfd_delete_bfd (nbfd);
553
      return NULL;
554
    }
555
 
556
  vec = bfd_zalloc (nbfd, sizeof (struct opncls));
557
  vec->stream = stream;
558
  vec->pread = pread;
559
  vec->close = close;
560
  vec->stat = stat;
561
 
562
  nbfd->iovec = &opncls_iovec;
563
  nbfd->iostream = vec;
564
 
565
  return nbfd;
566
}
567
 
568
/* bfd_openw -- open for writing.
569
   Returns a pointer to a freshly-allocated BFD on success, or NULL.
570
 
571
   See comment by bfd_fdopenr before you try to modify this function.  */
572
 
573
/*
574
FUNCTION
575
        bfd_openw
576
 
577
SYNOPSIS
578
        bfd *bfd_openw (const char *filename, const char *target);
579
 
580
DESCRIPTION
581
        Create a BFD, associated with file @var{filename}, using the
582
        file format @var{target}, and return a pointer to it.
583
 
584
        Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
585
        <<bfd_error_invalid_target>>.
586
*/
587
 
588
bfd *
589
bfd_openw (const char *filename, const char *target)
590
{
591
  bfd *nbfd;
592
  const bfd_target *target_vec;
593
 
594
  /* nbfd has to point to head of malloc'ed block so that bfd_close may
595
     reclaim it correctly.  */
596
  nbfd = _bfd_new_bfd ();
597
  if (nbfd == NULL)
598
    return NULL;
599
 
600
  target_vec = bfd_find_target (target, nbfd);
601
  if (target_vec == NULL)
602
    {
603
      _bfd_delete_bfd (nbfd);
604
      return NULL;
605
    }
606
 
607
  nbfd->filename = filename;
608
  nbfd->direction = write_direction;
609
 
610
  if (bfd_open_file (nbfd) == NULL)
611
    {
612
      /* File not writeable, etc.  */
613
      bfd_set_error (bfd_error_system_call);
614
      _bfd_delete_bfd (nbfd);
615
      return NULL;
616
  }
617
 
618
  return nbfd;
619
}
620
 
621
/*
622
 
623
FUNCTION
624
        bfd_close
625
 
626
SYNOPSIS
627
        bfd_boolean bfd_close (bfd *abfd);
628
 
629
DESCRIPTION
630
 
631
        Close a BFD. If the BFD was open for writing, then pending
632
        operations are completed and the file written out and closed.
633
        If the created file is executable, then <<chmod>> is called
634
        to mark it as such.
635
 
636
        All memory attached to the BFD is released.
637
 
638
        The file descriptor associated with the BFD is closed (even
639
        if it was passed in to BFD by <<bfd_fdopenr>>).
640
 
641
RETURNS
642
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
643
*/
644
 
645
 
646
bfd_boolean
647
bfd_close (bfd *abfd)
648
{
649
  bfd_boolean ret;
650
  bfd *nbfd;
651
  bfd *next;
652
 
653
  if (bfd_write_p (abfd))
654
    {
655
      if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
656
        return FALSE;
657
    }
658
 
659
  /* Close nested archives (if this bfd is a thin archive).  */
660
  for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
661
    {
662
      next = nbfd->archive_next;
663
      bfd_close (nbfd);
664
    }
665
 
666
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
667
    return FALSE;
668
 
669
  /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
670
     vector.  */
671
  if (!(abfd->flags & BFD_IN_MEMORY))
672
    ret = abfd->iovec->bclose (abfd);
673
  else
674
    ret = TRUE;
675
 
676
  /* If the file was open for writing and is now executable,
677
     make it so.  */
678
  if (ret
679
      && abfd->direction == write_direction
680
      && abfd->flags & EXEC_P)
681
    {
682
      struct stat buf;
683
 
684
      if (stat (abfd->filename, &buf) == 0)
685
        {
686
          unsigned int mask = umask (0);
687
 
688
          umask (mask);
689
          chmod (abfd->filename,
690
                 (0777
691
                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
692
        }
693
    }
694
 
695
  _bfd_delete_bfd (abfd);
696
 
697
  return ret;
698
}
699
 
700
/*
701
FUNCTION
702
        bfd_close_all_done
703
 
704
SYNOPSIS
705
        bfd_boolean bfd_close_all_done (bfd *);
706
 
707
DESCRIPTION
708
        Close a BFD.  Differs from <<bfd_close>> since it does not
709
        complete any pending operations.  This routine would be used
710
        if the application had just used BFD for swapping and didn't
711
        want to use any of the writing code.
712
 
713
        If the created file is executable, then <<chmod>> is called
714
        to mark it as such.
715
 
716
        All memory attached to the BFD is released.
717
 
718
RETURNS
719
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
720
*/
721
 
722
bfd_boolean
723
bfd_close_all_done (bfd *abfd)
724
{
725
  bfd_boolean ret;
726
 
727
  ret = bfd_cache_close (abfd);
728
 
729
  /* If the file was open for writing and is now executable,
730
     make it so.  */
731
  if (ret
732
      && abfd->direction == write_direction
733
      && abfd->flags & EXEC_P)
734
    {
735
      struct stat buf;
736
 
737
      if (stat (abfd->filename, &buf) == 0)
738
        {
739
          unsigned int mask = umask (0);
740
 
741
          umask (mask);
742
          chmod (abfd->filename,
743
                 (0777
744
                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
745
        }
746
    }
747
 
748
  _bfd_delete_bfd (abfd);
749
 
750
  return ret;
751
}
752
 
753
/*
754
FUNCTION
755
        bfd_create
756
 
757
SYNOPSIS
758
        bfd *bfd_create (const char *filename, bfd *templ);
759
 
760
DESCRIPTION
761
        Create a new BFD in the manner of <<bfd_openw>>, but without
762
        opening a file. The new BFD takes the target from the target
763
        used by @var{template}. The format is always set to <<bfd_object>>.
764
*/
765
 
766
bfd *
767
bfd_create (const char *filename, bfd *templ)
768
{
769
  bfd *nbfd;
770
 
771
  nbfd = _bfd_new_bfd ();
772
  if (nbfd == NULL)
773
    return NULL;
774
  nbfd->filename = filename;
775
  if (templ)
776
    nbfd->xvec = templ->xvec;
777
  nbfd->direction = no_direction;
778
  bfd_set_format (nbfd, bfd_object);
779
 
780
  return nbfd;
781
}
782
 
783
/*
784
FUNCTION
785
        bfd_make_writable
786
 
787
SYNOPSIS
788
        bfd_boolean bfd_make_writable (bfd *abfd);
789
 
790
DESCRIPTION
791
        Takes a BFD as created by <<bfd_create>> and converts it
792
        into one like as returned by <<bfd_openw>>.  It does this
793
        by converting the BFD to BFD_IN_MEMORY.  It's assumed that
794
        you will call <<bfd_make_readable>> on this bfd later.
795
 
796
RETURNS
797
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
798
*/
799
 
800
bfd_boolean
801
bfd_make_writable (bfd *abfd)
802
{
803
  struct bfd_in_memory *bim;
804
 
805
  if (abfd->direction != no_direction)
806
    {
807
      bfd_set_error (bfd_error_invalid_operation);
808
      return FALSE;
809
    }
810
 
811
  bim = bfd_malloc (sizeof (struct bfd_in_memory));
812
  if (bim == NULL)
813
    return FALSE;       /* bfd_error already set.  */
814
  abfd->iostream = bim;
815
  /* bfd_bwrite will grow these as needed.  */
816
  bim->size = 0;
817
  bim->buffer = 0;
818
 
819
  abfd->flags |= BFD_IN_MEMORY;
820
  abfd->direction = write_direction;
821
  abfd->where = 0;
822
 
823
  return TRUE;
824
}
825
 
826
/*
827
FUNCTION
828
        bfd_make_readable
829
 
830
SYNOPSIS
831
        bfd_boolean bfd_make_readable (bfd *abfd);
832
 
833
DESCRIPTION
834
        Takes a BFD as created by <<bfd_create>> and
835
        <<bfd_make_writable>> and converts it into one like as
836
        returned by <<bfd_openr>>.  It does this by writing the
837
        contents out to the memory buffer, then reversing the
838
        direction.
839
 
840
RETURNS
841
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
842
 
843
bfd_boolean
844
bfd_make_readable (bfd *abfd)
845
{
846
  if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
847
    {
848
      bfd_set_error (bfd_error_invalid_operation);
849
      return FALSE;
850
    }
851
 
852
  if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
853
    return FALSE;
854
 
855
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
856
    return FALSE;
857
 
858
 
859
  abfd->arch_info = &bfd_default_arch_struct;
860
 
861
  abfd->where = 0;
862
  abfd->format = bfd_unknown;
863
  abfd->my_archive = NULL;
864
  abfd->origin = 0;
865
  abfd->opened_once = FALSE;
866
  abfd->output_has_begun = FALSE;
867
  abfd->section_count = 0;
868
  abfd->usrdata = NULL;
869
  abfd->cacheable = FALSE;
870
  abfd->flags = BFD_IN_MEMORY;
871
  abfd->mtime_set = FALSE;
872
 
873
  abfd->target_defaulted = TRUE;
874
  abfd->direction = read_direction;
875
  abfd->sections = 0;
876
  abfd->symcount = 0;
877
  abfd->outsymbols = 0;
878
  abfd->tdata.any = 0;
879
 
880
  bfd_section_list_clear (abfd);
881
  bfd_check_format (abfd, bfd_object);
882
 
883
  return TRUE;
884
}
885
 
886
/*
887
INTERNAL_FUNCTION
888
        bfd_alloc
889
 
890
SYNOPSIS
891
        void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
892
 
893
DESCRIPTION
894
        Allocate a block of @var{wanted} bytes of memory attached to
895
        <<abfd>> and return a pointer to it.
896
*/
897
 
898
void *
899
bfd_alloc (bfd *abfd, bfd_size_type size)
900
{
901
  void *ret;
902
 
903
  if (size != (unsigned long) size)
904
    {
905
      bfd_set_error (bfd_error_no_memory);
906
      return NULL;
907
    }
908
 
909
  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
910
  if (ret == NULL)
911
    bfd_set_error (bfd_error_no_memory);
912
  return ret;
913
}
914
 
915
/*
916
INTERNAL_FUNCTION
917
        bfd_alloc2
918
 
919
SYNOPSIS
920
        void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
921
 
922
DESCRIPTION
923
        Allocate a block of @var{nmemb} elements of @var{size} bytes each
924
        of memory attached to <<abfd>> and return a pointer to it.
925
*/
926
 
927
void *
928
bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
929
{
930
  void *ret;
931
 
932
  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
933
      && size != 0
934
      && nmemb > ~(bfd_size_type) 0 / size)
935
    {
936
      bfd_set_error (bfd_error_no_memory);
937
      return NULL;
938
    }
939
 
940
  size *= nmemb;
941
 
942
  if (size != (unsigned long) size)
943
    {
944
      bfd_set_error (bfd_error_no_memory);
945
      return NULL;
946
    }
947
 
948
  ret = objalloc_alloc (abfd->memory, (unsigned long) size);
949
  if (ret == NULL)
950
    bfd_set_error (bfd_error_no_memory);
951
  return ret;
952
}
953
 
954
/*
955
INTERNAL_FUNCTION
956
        bfd_zalloc
957
 
958
SYNOPSIS
959
        void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
960
 
961
DESCRIPTION
962
        Allocate a block of @var{wanted} bytes of zeroed memory
963
        attached to <<abfd>> and return a pointer to it.
964
*/
965
 
966
void *
967
bfd_zalloc (bfd *abfd, bfd_size_type size)
968
{
969
  void *res;
970
 
971
  res = bfd_alloc (abfd, size);
972
  if (res)
973
    memset (res, 0, (size_t) size);
974
  return res;
975
}
976
 
977
/*
978
INTERNAL_FUNCTION
979
        bfd_zalloc2
980
 
981
SYNOPSIS
982
        void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
983
 
984
DESCRIPTION
985
        Allocate a block of @var{nmemb} elements of @var{size} bytes each
986
        of zeroed memory attached to <<abfd>> and return a pointer to it.
987
*/
988
 
989
void *
990
bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
991
{
992
  void *res;
993
 
994
  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
995
      && size != 0
996
      && nmemb > ~(bfd_size_type) 0 / size)
997
    {
998
      bfd_set_error (bfd_error_no_memory);
999
      return NULL;
1000
    }
1001
 
1002
  size *= nmemb;
1003
 
1004
  res = bfd_alloc (abfd, size);
1005
  if (res)
1006
    memset (res, 0, (size_t) size);
1007
  return res;
1008
}
1009
 
1010
/* Free a block allocated for a BFD.
1011
   Note:  Also frees all more recently allocated blocks!  */
1012
 
1013
void
1014
bfd_release (bfd *abfd, void *block)
1015
{
1016
  objalloc_free_block ((struct objalloc *) abfd->memory, block);
1017
}
1018
 
1019
 
1020
/*
1021
   GNU Extension: separate debug-info files
1022
 
1023
   The idea here is that a special section called .gnu_debuglink might be
1024
   embedded in a binary file, which indicates that some *other* file
1025
   contains the real debugging information. This special section contains a
1026
   filename and CRC32 checksum, which we read and resolve to another file,
1027
   if it exists.
1028
 
1029
   This facilitates "optional" provision of debugging information, without
1030
   having to provide two complete copies of every binary object (with and
1031
   without debug symbols).
1032
*/
1033
 
1034
#define GNU_DEBUGLINK   ".gnu_debuglink"
1035
/*
1036
FUNCTION
1037
        bfd_calc_gnu_debuglink_crc32
1038
 
1039
SYNOPSIS
1040
        unsigned long bfd_calc_gnu_debuglink_crc32
1041
          (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1042
 
1043
DESCRIPTION
1044
        Computes a CRC value as used in the .gnu_debuglink section.
1045
        Advances the previously computed @var{crc} value by computing
1046
        and adding in the crc32 for @var{len} bytes of @var{buf}.
1047
 
1048
RETURNS
1049
        Return the updated CRC32 value.
1050
*/
1051
 
1052
unsigned long
1053
bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1054
                              const unsigned char *buf,
1055
                              bfd_size_type len)
1056
{
1057
  static const unsigned long crc32_table[256] =
1058
    {
1059
      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1060
      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1061
      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1062
      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1063
      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1064
      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1065
      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1066
      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1067
      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1068
      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1069
      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1070
      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1071
      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1072
      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1073
      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1074
      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1075
      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1076
      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1077
      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1078
      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1079
      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1080
      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1081
      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1082
      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1083
      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1084
      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1085
      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1086
      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1087
      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1088
      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1089
      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1090
      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1091
      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1092
      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1093
      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1094
      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1095
      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1096
      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1097
      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1098
      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1099
      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1100
      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1101
      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1102
      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1103
      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1104
      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1105
      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1106
      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1107
      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1108
      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1109
      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1110
      0x2d02ef8d
1111
    };
1112
  const unsigned char *end;
1113
 
1114
  crc = ~crc & 0xffffffff;
1115
  for (end = buf + len; buf < end; ++ buf)
1116
    crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1117
  return ~crc & 0xffffffff;;
1118
}
1119
 
1120
 
1121
/*
1122
INTERNAL_FUNCTION
1123
        get_debug_link_info
1124
 
1125
SYNOPSIS
1126
        char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1127
 
1128
DESCRIPTION
1129
        fetch the filename and CRC32 value for any separate debuginfo
1130
        associated with @var{abfd}. Return NULL if no such info found,
1131
        otherwise return filename and update @var{crc32_out}.
1132
*/
1133
 
1134
static char *
1135
get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1136
{
1137
  asection *sect;
1138
  unsigned long crc32;
1139
  bfd_byte *contents;
1140
  int crc_offset;
1141
  char *name;
1142
 
1143
  BFD_ASSERT (abfd);
1144
  BFD_ASSERT (crc32_out);
1145
 
1146
  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1147
 
1148
  if (sect == NULL)
1149
    return NULL;
1150
 
1151
  if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1152
    {
1153
      if (contents != NULL)
1154
        free (contents);
1155
      return NULL;
1156
    }
1157
 
1158
  /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1159
  name = (char *) contents;
1160
  crc_offset = strlen (name) + 1;
1161
  crc_offset = (crc_offset + 3) & ~3;
1162
 
1163
  crc32 = bfd_get_32 (abfd, contents + crc_offset);
1164
 
1165
  *crc32_out = crc32;
1166
  return name;
1167
}
1168
 
1169
/*
1170
INTERNAL_FUNCTION
1171
        separate_debug_file_exists
1172
 
1173
SYNOPSIS
1174
        bfd_boolean separate_debug_file_exists
1175
          (char *name, unsigned long crc32);
1176
 
1177
DESCRIPTION
1178
        Checks to see if @var{name} is a file and if its contents
1179
        match @var{crc32}.
1180
*/
1181
 
1182
static bfd_boolean
1183
separate_debug_file_exists (const char *name, const unsigned long crc)
1184
{
1185
  static unsigned char buffer [8 * 1024];
1186
  unsigned long file_crc = 0;
1187
  FILE *f;
1188
  bfd_size_type count;
1189
 
1190
  BFD_ASSERT (name);
1191
 
1192
  f = real_fopen (name, FOPEN_RB);
1193
  if (f == NULL)
1194
    return FALSE;
1195
 
1196
  while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1197
    file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1198
 
1199
  fclose (f);
1200
 
1201
  return crc == file_crc;
1202
}
1203
 
1204
 
1205
/*
1206
INTERNAL_FUNCTION
1207
        find_separate_debug_file
1208
 
1209
SYNOPSIS
1210
        char *find_separate_debug_file (bfd *abfd);
1211
 
1212
DESCRIPTION
1213
        Searches @var{abfd} for a reference to separate debugging
1214
        information, scans various locations in the filesystem, including
1215
        the file tree rooted at @var{debug_file_directory}, and returns a
1216
        filename of such debugging information if the file is found and has
1217
        matching CRC32.  Returns NULL if no reference to debugging file
1218
        exists, or file cannot be found.
1219
*/
1220
 
1221
static char *
1222
find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1223
{
1224
  char *basename;
1225
  char *dir;
1226
  char *debugfile;
1227
  unsigned long crc32;
1228
  int i;
1229
  size_t dirlen;
1230
 
1231
  BFD_ASSERT (abfd);
1232
  if (debug_file_directory == NULL)
1233
    debug_file_directory = ".";
1234
 
1235
  /* BFD may have been opened from a stream.  */
1236
  if (abfd->filename == NULL)
1237
    {
1238
      bfd_set_error (bfd_error_invalid_operation);
1239
      return NULL;
1240
    }
1241
 
1242
  basename = get_debug_link_info (abfd, & crc32);
1243
  if (basename == NULL)
1244
    return NULL;
1245
 
1246
  if (basename[0] == '\0')
1247
    {
1248
      free (basename);
1249
      bfd_set_error (bfd_error_no_debug_section);
1250
      return NULL;
1251
    }
1252
 
1253
  for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1254
    if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1255
      break;
1256
 
1257
  dir = bfd_malloc (dirlen + 1);
1258
  if (dir == NULL)
1259
    {
1260
      free (basename);
1261
      return NULL;
1262
    }
1263
  memcpy (dir, abfd->filename, dirlen);
1264
  dir[dirlen] = '\0';
1265
 
1266
  debugfile = bfd_malloc (strlen (debug_file_directory) + 1
1267
                          + dirlen
1268
                          + strlen (".debug/")
1269
                          + strlen (basename)
1270
                          + 1);
1271
  if (debugfile == NULL)
1272
    {
1273
      free (basename);
1274
      free (dir);
1275
      return NULL;
1276
    }
1277
 
1278
  /* First try in the same directory as the original file:  */
1279
  strcpy (debugfile, dir);
1280
  strcat (debugfile, basename);
1281
 
1282
  if (separate_debug_file_exists (debugfile, crc32))
1283
    {
1284
      free (basename);
1285
      free (dir);
1286
      return debugfile;
1287
    }
1288
 
1289
  /* Then try in a subdirectory called .debug.  */
1290
  strcpy (debugfile, dir);
1291
  strcat (debugfile, ".debug/");
1292
  strcat (debugfile, basename);
1293
 
1294
  if (separate_debug_file_exists (debugfile, crc32))
1295
    {
1296
      free (basename);
1297
      free (dir);
1298
      return debugfile;
1299
    }
1300
 
1301
  /* Then try in the global debugfile directory.  */
1302
  strcpy (debugfile, debug_file_directory);
1303
  i = strlen (debug_file_directory) - 1;
1304
  if (i > 0
1305
      && debug_file_directory[i] != '/'
1306
      && dir[0] != '/')
1307
    strcat (debugfile, "/");
1308
  strcat (debugfile, dir);
1309
  strcat (debugfile, basename);
1310
 
1311
  if (separate_debug_file_exists (debugfile, crc32))
1312
    {
1313
      free (basename);
1314
      free (dir);
1315
      return debugfile;
1316
    }
1317
 
1318
  free (debugfile);
1319
  free (basename);
1320
  free (dir);
1321
  return NULL;
1322
}
1323
 
1324
 
1325
/*
1326
FUNCTION
1327
        bfd_follow_gnu_debuglink
1328
 
1329
SYNOPSIS
1330
        char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1331
 
1332
DESCRIPTION
1333
 
1334
        Takes a BFD and searches it for a .gnu_debuglink section.  If this
1335
        section is found, it examines the section for the name and checksum
1336
        of a '.debug' file containing auxiliary debugging information.  It
1337
        then searches the filesystem for this .debug file in some standard
1338
        locations, including the directory tree rooted at @var{dir}, and if
1339
        found returns the full filename.
1340
 
1341
        If @var{dir} is NULL, it will search a default path configured into
1342
        libbfd at build time.  [XXX this feature is not currently
1343
        implemented].
1344
 
1345
RETURNS
1346
        <<NULL>> on any errors or failure to locate the .debug file,
1347
        otherwise a pointer to a heap-allocated string containing the
1348
        filename.  The caller is responsible for freeing this string.
1349
*/
1350
 
1351
char *
1352
bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1353
{
1354
  return find_separate_debug_file (abfd, dir);
1355
}
1356
 
1357
/*
1358
FUNCTION
1359
        bfd_create_gnu_debuglink_section
1360
 
1361
SYNOPSIS
1362
        struct bfd_section *bfd_create_gnu_debuglink_section
1363
          (bfd *abfd, const char *filename);
1364
 
1365
DESCRIPTION
1366
 
1367
        Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1368
        to be big enough to contain a link to the specified @var{filename}.
1369
 
1370
RETURNS
1371
        A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1372
        returned and bfd_error is set.
1373
*/
1374
 
1375
asection *
1376
bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1377
{
1378
  asection *sect;
1379
  bfd_size_type debuglink_size;
1380
  flagword flags;
1381
 
1382
  if (abfd == NULL || filename == NULL)
1383
    {
1384
      bfd_set_error (bfd_error_invalid_operation);
1385
      return NULL;
1386
    }
1387
 
1388
  /* Strip off any path components in filename.  */
1389
  filename = lbasename (filename);
1390
 
1391
  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1392
  if (sect)
1393
    {
1394
      /* Section already exists.  */
1395
      bfd_set_error (bfd_error_invalid_operation);
1396
      return NULL;
1397
    }
1398
 
1399
  flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1400
  sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1401
  if (sect == NULL)
1402
    return NULL;
1403
 
1404
  debuglink_size = strlen (filename) + 1;
1405
  debuglink_size += 3;
1406
  debuglink_size &= ~3;
1407
  debuglink_size += 4;
1408
 
1409
  if (! bfd_set_section_size (abfd, sect, debuglink_size))
1410
    /* XXX Should we delete the section from the bfd ?  */
1411
    return NULL;
1412
 
1413
  return sect;
1414
}
1415
 
1416
 
1417
/*
1418
FUNCTION
1419
        bfd_fill_in_gnu_debuglink_section
1420
 
1421
SYNOPSIS
1422
        bfd_boolean bfd_fill_in_gnu_debuglink_section
1423
          (bfd *abfd, struct bfd_section *sect, const char *filename);
1424
 
1425
DESCRIPTION
1426
 
1427
        Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1428
        and fills in the contents of the section to contain a link to the
1429
        specified @var{filename}.  The filename should be relative to the
1430
        current directory.
1431
 
1432
RETURNS
1433
        <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1434
        and bfd_error is set.
1435
*/
1436
 
1437
bfd_boolean
1438
bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1439
                                   struct bfd_section *sect,
1440
                                   const char *filename)
1441
{
1442
  bfd_size_type debuglink_size;
1443
  unsigned long crc32;
1444
  char * contents;
1445
  bfd_size_type crc_offset;
1446
  FILE * handle;
1447
  static unsigned char buffer[8 * 1024];
1448
  size_t count;
1449
  size_t filelen;
1450
 
1451
  if (abfd == NULL || sect == NULL || filename == NULL)
1452
    {
1453
      bfd_set_error (bfd_error_invalid_operation);
1454
      return FALSE;
1455
    }
1456
 
1457
  /* Make sure that we can read the file.
1458
     XXX - Should we attempt to locate the debug info file using the same
1459
     algorithm as gdb ?  At the moment, since we are creating the
1460
     .gnu_debuglink section, we insist upon the user providing us with a
1461
     correct-for-section-creation-time path, but this need not conform to
1462
     the gdb location algorithm.  */
1463
  handle = real_fopen (filename, FOPEN_RB);
1464
  if (handle == NULL)
1465
    {
1466
      bfd_set_error (bfd_error_system_call);
1467
      return FALSE;
1468
    }
1469
 
1470
  crc32 = 0;
1471
  while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1472
    crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1473
  fclose (handle);
1474
 
1475
  /* Strip off any path components in filename,
1476
     now that we no longer need them.  */
1477
  filename = lbasename (filename);
1478
 
1479
  filelen = strlen (filename);
1480
  debuglink_size = filelen + 1;
1481
  debuglink_size += 3;
1482
  debuglink_size &= ~3;
1483
  debuglink_size += 4;
1484
 
1485
  contents = bfd_malloc (debuglink_size);
1486
  if (contents == NULL)
1487
    {
1488
      /* XXX Should we delete the section from the bfd ?  */
1489
      return FALSE;
1490
    }
1491
 
1492
  crc_offset = debuglink_size - 4;
1493
  memcpy (contents, filename, filelen);
1494
  memset (contents + filelen, 0, crc_offset - filelen);
1495
 
1496
  bfd_put_32 (abfd, crc32, contents + crc_offset);
1497
 
1498
  if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1499
    {
1500
      /* XXX Should we delete the section from the bfd ?  */
1501
      free (contents);
1502
      return FALSE;
1503
    }
1504
 
1505
  return TRUE;
1506
}

powered by: WebSVN 2.1.0

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