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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [opncls.c] - Blame information for rev 90

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

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

powered by: WebSVN 2.1.0

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