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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [opncls.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* 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
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 *) 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 = (FILE *) 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_func) (struct bfd *nbfd,
380
                                                  void *open_closure),
381
                              void *open_closure,
382
                              file_ptr (*pread_func) (struct bfd *nbfd,
383
                                                      void *stream,
384
                                                      void *buf,
385
                                                      file_ptr nbytes,
386
                                                      file_ptr offset),
387
                              int (*close_func) (struct bfd *nbfd,
388
                                                 void *stream),
389
                              int (*stat_func) (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_func}, accessed using
397
        @var{pread_func} and destroyed using @var{close_func}.
398
 
399
        Calls <<bfd_find_target>>, so @var{target} is interpreted as by
400
        that function.
401
 
402
        Calls @var{open_func} (which can call <<bfd_zalloc>> and
403
        <<bfd_get_filename>>) to obtain the read-only stream backing
404
        the BFD.  @var{open_func} either succeeds returning the
405
        non-<<NULL>> @var{stream}, or fails returning <<NULL>>
406
        (setting <<bfd_error>>).
407
 
408
        Calls @var{pread_func} 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_func} 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_func} when the BFD is later closed using
415
        <<bfd_close>>.  @var{close_func} either succeeds returning 0, or
416
        fails returning -1 (setting <<bfd_error>>).
417
 
418
        Calls @var{stat_func} to fill in a stat structure for bfd_stat,
419
        bfd_get_size, and bfd_get_mtime calls.  @var{stat_func} 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 = (struct opncls *) 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 = (struct opncls *) 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 = (struct opncls *) 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 = (struct opncls *) 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 = (struct opncls *) 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 void *
509
opncls_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
510
              void *addr ATTRIBUTE_UNUSED,
511
              bfd_size_type len ATTRIBUTE_UNUSED,
512
              int prot ATTRIBUTE_UNUSED,
513
              int flags ATTRIBUTE_UNUSED,
514
              file_ptr offset ATTRIBUTE_UNUSED)
515
{
516
  return (void *) -1;
517
}
518
 
519
static const struct bfd_iovec opncls_iovec = {
520
  &opncls_bread, &opncls_bwrite, &opncls_btell, &opncls_bseek,
521
  &opncls_bclose, &opncls_bflush, &opncls_bstat, &opncls_bmmap
522
};
523
 
524
bfd *
525
bfd_openr_iovec (const char *filename, const char *target,
526
                 void *(*open_p) (struct bfd *, void *),
527
                 void *open_closure,
528
                 file_ptr (*pread_p) (struct bfd *, void *, void *,
529
                                      file_ptr, file_ptr),
530
                 int (*close_p) (struct bfd *, void *),
531
                 int (*stat_p) (struct bfd *, void *, struct stat *))
532
{
533
  bfd *nbfd;
534
  const bfd_target *target_vec;
535
  struct opncls *vec;
536
  void *stream;
537
 
538
  nbfd = _bfd_new_bfd ();
539
  if (nbfd == NULL)
540
    return NULL;
541
 
542
  target_vec = bfd_find_target (target, nbfd);
543
  if (target_vec == NULL)
544
    {
545
      _bfd_delete_bfd (nbfd);
546
      return NULL;
547
    }
548
 
549
  nbfd->filename = filename;
550
  nbfd->direction = read_direction;
551
 
552
  /* `open_p (...)' would get expanded by an the open(2) syscall macro.  */
553
  stream = (*open_p) (nbfd, open_closure);
554
  if (stream == NULL)
555
    {
556
      _bfd_delete_bfd (nbfd);
557
      return NULL;
558
    }
559
 
560
  vec = (struct opncls *) bfd_zalloc (nbfd, sizeof (struct opncls));
561
  vec->stream = stream;
562
  vec->pread = pread_p;
563
  vec->close = close_p;
564
  vec->stat = stat_p;
565
 
566
  nbfd->iovec = &opncls_iovec;
567
  nbfd->iostream = vec;
568
 
569
  return nbfd;
570
}
571
 
572
/* bfd_openw -- open for writing.
573
   Returns a pointer to a freshly-allocated BFD on success, or NULL.
574
 
575
   See comment by bfd_fdopenr before you try to modify this function.  */
576
 
577
/*
578
FUNCTION
579
        bfd_openw
580
 
581
SYNOPSIS
582
        bfd *bfd_openw (const char *filename, const char *target);
583
 
584
DESCRIPTION
585
        Create a BFD, associated with file @var{filename}, using the
586
        file format @var{target}, and return a pointer to it.
587
 
588
        Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>,
589
        <<bfd_error_invalid_target>>.
590
*/
591
 
592
bfd *
593
bfd_openw (const char *filename, const char *target)
594
{
595
  bfd *nbfd;
596
  const bfd_target *target_vec;
597
 
598
  /* nbfd has to point to head of malloc'ed block so that bfd_close may
599
     reclaim it correctly.  */
600
  nbfd = _bfd_new_bfd ();
601
  if (nbfd == NULL)
602
    return NULL;
603
 
604
  target_vec = bfd_find_target (target, nbfd);
605
  if (target_vec == NULL)
606
    {
607
      _bfd_delete_bfd (nbfd);
608
      return NULL;
609
    }
610
 
611
  nbfd->filename = filename;
612
  nbfd->direction = write_direction;
613
 
614
  if (bfd_open_file (nbfd) == NULL)
615
    {
616
      /* File not writeable, etc.  */
617
      bfd_set_error (bfd_error_system_call);
618
      _bfd_delete_bfd (nbfd);
619
      return NULL;
620
  }
621
 
622
  return nbfd;
623
}
624
 
625
static inline void
626
_maybe_make_executable (bfd * abfd)
627
{
628
  /* If the file was open for writing and is now executable,
629
     make it so.  */
630
  if (abfd->direction == write_direction
631
      && (abfd->flags & (EXEC_P | DYNAMIC)) != 0)
632
    {
633
      struct stat buf;
634
 
635
      if (stat (abfd->filename, &buf) == 0
636
          /* Do not attempt to change non-regular files.  This is
637
             here especially for configure scripts and kernel builds
638
             which run tests with "ld [...] -o /dev/null".  */
639
          && S_ISREG(buf.st_mode))
640
        {
641
          unsigned int mask = umask (0);
642
 
643
          umask (mask);
644
          chmod (abfd->filename,
645
                 (0777
646
                  & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask))));
647
        }
648
    }
649
}
650
 
651
/*
652
 
653
FUNCTION
654
        bfd_close
655
 
656
SYNOPSIS
657
        bfd_boolean bfd_close (bfd *abfd);
658
 
659
DESCRIPTION
660
 
661
        Close a BFD. If the BFD was open for writing, then pending
662
        operations are completed and the file written out and closed.
663
        If the created file is executable, then <<chmod>> is called
664
        to mark it as such.
665
 
666
        All memory attached to the BFD is released.
667
 
668
        The file descriptor associated with the BFD is closed (even
669
        if it was passed in to BFD by <<bfd_fdopenr>>).
670
 
671
RETURNS
672
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
673
*/
674
 
675
 
676
bfd_boolean
677
bfd_close (bfd *abfd)
678
{
679
  bfd_boolean ret;
680
  bfd *nbfd;
681
  bfd *next;
682
 
683
  if (bfd_write_p (abfd))
684
    {
685
      if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
686
        return FALSE;
687
    }
688
 
689
  /* Close nested archives (if this bfd is a thin archive).  */
690
  for (nbfd = abfd->nested_archives; nbfd; nbfd = next)
691
    {
692
      next = nbfd->archive_next;
693
      bfd_close (nbfd);
694
    }
695
 
696
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
697
    return FALSE;
698
 
699
  if ((abfd->flags & BFD_IN_MEMORY) != 0)
700
    {
701
      /* FIXME: cagney/2004-02-15: Need to implement a BFD_IN_MEMORY io
702
         vector.
703
         Until that's done, at least don't leak memory.  */
704
      struct bfd_in_memory *bim = (struct bfd_in_memory *) abfd->iostream;
705
 
706
      if (bim->buffer != NULL)
707
        free (bim->buffer);
708
      free (bim);
709
      ret = TRUE;
710
    }
711
  else
712
    ret = abfd->iovec->bclose (abfd);
713
 
714
  if (ret)
715
    _maybe_make_executable (abfd);
716
 
717
  _bfd_delete_bfd (abfd);
718
 
719
  return ret;
720
}
721
 
722
/*
723
FUNCTION
724
        bfd_close_all_done
725
 
726
SYNOPSIS
727
        bfd_boolean bfd_close_all_done (bfd *);
728
 
729
DESCRIPTION
730
        Close a BFD.  Differs from <<bfd_close>> since it does not
731
        complete any pending operations.  This routine would be used
732
        if the application had just used BFD for swapping and didn't
733
        want to use any of the writing code.
734
 
735
        If the created file is executable, then <<chmod>> is called
736
        to mark it as such.
737
 
738
        All memory attached to the BFD is released.
739
 
740
RETURNS
741
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
742
*/
743
 
744
bfd_boolean
745
bfd_close_all_done (bfd *abfd)
746
{
747
  bfd_boolean ret;
748
 
749
  ret = bfd_cache_close (abfd);
750
 
751
  if (ret)
752
    _maybe_make_executable (abfd);
753
 
754
  _bfd_delete_bfd (abfd);
755
 
756
  return ret;
757
}
758
 
759
/*
760
FUNCTION
761
        bfd_create
762
 
763
SYNOPSIS
764
        bfd *bfd_create (const char *filename, bfd *templ);
765
 
766
DESCRIPTION
767
        Create a new BFD in the manner of <<bfd_openw>>, but without
768
        opening a file. The new BFD takes the target from the target
769
        used by @var{template}. The format is always set to <<bfd_object>>.
770
*/
771
 
772
bfd *
773
bfd_create (const char *filename, bfd *templ)
774
{
775
  bfd *nbfd;
776
 
777
  nbfd = _bfd_new_bfd ();
778
  if (nbfd == NULL)
779
    return NULL;
780
  nbfd->filename = filename;
781
  if (templ)
782
    nbfd->xvec = templ->xvec;
783
  nbfd->direction = no_direction;
784
  bfd_set_format (nbfd, bfd_object);
785
 
786
  return nbfd;
787
}
788
 
789
/*
790
FUNCTION
791
        bfd_make_writable
792
 
793
SYNOPSIS
794
        bfd_boolean bfd_make_writable (bfd *abfd);
795
 
796
DESCRIPTION
797
        Takes a BFD as created by <<bfd_create>> and converts it
798
        into one like as returned by <<bfd_openw>>.  It does this
799
        by converting the BFD to BFD_IN_MEMORY.  It's assumed that
800
        you will call <<bfd_make_readable>> on this bfd later.
801
 
802
RETURNS
803
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.
804
*/
805
 
806
bfd_boolean
807
bfd_make_writable (bfd *abfd)
808
{
809
  struct bfd_in_memory *bim;
810
 
811
  if (abfd->direction != no_direction)
812
    {
813
      bfd_set_error (bfd_error_invalid_operation);
814
      return FALSE;
815
    }
816
 
817
  bim = (struct bfd_in_memory *) bfd_malloc (sizeof (struct bfd_in_memory));
818
  if (bim == NULL)
819
    return FALSE;       /* bfd_error already set.  */
820
  abfd->iostream = bim;
821
  /* bfd_bwrite will grow these as needed.  */
822
  bim->size = 0;
823
  bim->buffer = 0;
824
 
825
  abfd->flags |= BFD_IN_MEMORY;
826
  abfd->direction = write_direction;
827
  abfd->where = 0;
828
 
829
  return TRUE;
830
}
831
 
832
/*
833
FUNCTION
834
        bfd_make_readable
835
 
836
SYNOPSIS
837
        bfd_boolean bfd_make_readable (bfd *abfd);
838
 
839
DESCRIPTION
840
        Takes a BFD as created by <<bfd_create>> and
841
        <<bfd_make_writable>> and converts it into one like as
842
        returned by <<bfd_openr>>.  It does this by writing the
843
        contents out to the memory buffer, then reversing the
844
        direction.
845
 
846
RETURNS
847
        <<TRUE>> is returned if all is ok, otherwise <<FALSE>>.  */
848
 
849
bfd_boolean
850
bfd_make_readable (bfd *abfd)
851
{
852
  if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY))
853
    {
854
      bfd_set_error (bfd_error_invalid_operation);
855
      return FALSE;
856
    }
857
 
858
  if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd)))
859
    return FALSE;
860
 
861
  if (! BFD_SEND (abfd, _close_and_cleanup, (abfd)))
862
    return FALSE;
863
 
864
 
865
  abfd->arch_info = &bfd_default_arch_struct;
866
 
867
  abfd->where = 0;
868
  abfd->format = bfd_unknown;
869
  abfd->my_archive = NULL;
870
  abfd->origin = 0;
871
  abfd->opened_once = FALSE;
872
  abfd->output_has_begun = FALSE;
873
  abfd->section_count = 0;
874
  abfd->usrdata = NULL;
875
  abfd->cacheable = FALSE;
876
  abfd->flags = BFD_IN_MEMORY;
877
  abfd->mtime_set = FALSE;
878
 
879
  abfd->target_defaulted = TRUE;
880
  abfd->direction = read_direction;
881
  abfd->sections = 0;
882
  abfd->symcount = 0;
883
  abfd->outsymbols = 0;
884
  abfd->tdata.any = 0;
885
 
886
  bfd_section_list_clear (abfd);
887
  bfd_check_format (abfd, bfd_object);
888
 
889
  return TRUE;
890
}
891
 
892
/*
893
INTERNAL_FUNCTION
894
        bfd_alloc
895
 
896
SYNOPSIS
897
        void *bfd_alloc (bfd *abfd, bfd_size_type wanted);
898
 
899
DESCRIPTION
900
        Allocate a block of @var{wanted} bytes of memory attached to
901
        <<abfd>> and return a pointer to it.
902
*/
903
 
904
void *
905
bfd_alloc (bfd *abfd, bfd_size_type size)
906
{
907
  void *ret;
908
 
909
  if (size != (unsigned long) size)
910
    {
911
      bfd_set_error (bfd_error_no_memory);
912
      return NULL;
913
    }
914
 
915
  ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
916
  if (ret == NULL)
917
    bfd_set_error (bfd_error_no_memory);
918
  return ret;
919
}
920
 
921
/*
922
INTERNAL_FUNCTION
923
        bfd_alloc2
924
 
925
SYNOPSIS
926
        void *bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
927
 
928
DESCRIPTION
929
        Allocate a block of @var{nmemb} elements of @var{size} bytes each
930
        of memory attached to <<abfd>> and return a pointer to it.
931
*/
932
 
933
void *
934
bfd_alloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
935
{
936
  void *ret;
937
 
938
  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
939
      && size != 0
940
      && nmemb > ~(bfd_size_type) 0 / size)
941
    {
942
      bfd_set_error (bfd_error_no_memory);
943
      return NULL;
944
    }
945
 
946
  size *= nmemb;
947
 
948
  if (size != (unsigned long) size)
949
    {
950
      bfd_set_error (bfd_error_no_memory);
951
      return NULL;
952
    }
953
 
954
  ret = objalloc_alloc ((struct objalloc *) abfd->memory, (unsigned long) size);
955
  if (ret == NULL)
956
    bfd_set_error (bfd_error_no_memory);
957
  return ret;
958
}
959
 
960
/*
961
INTERNAL_FUNCTION
962
        bfd_zalloc
963
 
964
SYNOPSIS
965
        void *bfd_zalloc (bfd *abfd, bfd_size_type wanted);
966
 
967
DESCRIPTION
968
        Allocate a block of @var{wanted} bytes of zeroed memory
969
        attached to <<abfd>> and return a pointer to it.
970
*/
971
 
972
void *
973
bfd_zalloc (bfd *abfd, bfd_size_type size)
974
{
975
  void *res;
976
 
977
  res = bfd_alloc (abfd, size);
978
  if (res)
979
    memset (res, 0, (size_t) size);
980
  return res;
981
}
982
 
983
/*
984
INTERNAL_FUNCTION
985
        bfd_zalloc2
986
 
987
SYNOPSIS
988
        void *bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size);
989
 
990
DESCRIPTION
991
        Allocate a block of @var{nmemb} elements of @var{size} bytes each
992
        of zeroed memory attached to <<abfd>> and return a pointer to it.
993
*/
994
 
995
void *
996
bfd_zalloc2 (bfd *abfd, bfd_size_type nmemb, bfd_size_type size)
997
{
998
  void *res;
999
 
1000
  if ((nmemb | size) >= HALF_BFD_SIZE_TYPE
1001
      && size != 0
1002
      && nmemb > ~(bfd_size_type) 0 / size)
1003
    {
1004
      bfd_set_error (bfd_error_no_memory);
1005
      return NULL;
1006
    }
1007
 
1008
  size *= nmemb;
1009
 
1010
  res = bfd_alloc (abfd, size);
1011
  if (res)
1012
    memset (res, 0, (size_t) size);
1013
  return res;
1014
}
1015
 
1016
/* Free a block allocated for a BFD.
1017
   Note:  Also frees all more recently allocated blocks!  */
1018
 
1019
void
1020
bfd_release (bfd *abfd, void *block)
1021
{
1022
  objalloc_free_block ((struct objalloc *) abfd->memory, block);
1023
}
1024
 
1025
 
1026
/*
1027
   GNU Extension: separate debug-info files
1028
 
1029
   The idea here is that a special section called .gnu_debuglink might be
1030
   embedded in a binary file, which indicates that some *other* file
1031
   contains the real debugging information. This special section contains a
1032
   filename and CRC32 checksum, which we read and resolve to another file,
1033
   if it exists.
1034
 
1035
   This facilitates "optional" provision of debugging information, without
1036
   having to provide two complete copies of every binary object (with and
1037
   without debug symbols).
1038
*/
1039
 
1040
#define GNU_DEBUGLINK   ".gnu_debuglink"
1041
/*
1042
FUNCTION
1043
        bfd_calc_gnu_debuglink_crc32
1044
 
1045
SYNOPSIS
1046
        unsigned long bfd_calc_gnu_debuglink_crc32
1047
          (unsigned long crc, const unsigned char *buf, bfd_size_type len);
1048
 
1049
DESCRIPTION
1050
        Computes a CRC value as used in the .gnu_debuglink section.
1051
        Advances the previously computed @var{crc} value by computing
1052
        and adding in the crc32 for @var{len} bytes of @var{buf}.
1053
 
1054
RETURNS
1055
        Return the updated CRC32 value.
1056
*/
1057
 
1058
unsigned long
1059
bfd_calc_gnu_debuglink_crc32 (unsigned long crc,
1060
                              const unsigned char *buf,
1061
                              bfd_size_type len)
1062
{
1063
  static const unsigned long crc32_table[256] =
1064
    {
1065
      0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
1066
      0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
1067
      0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
1068
      0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
1069
      0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
1070
      0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
1071
      0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
1072
      0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
1073
      0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
1074
      0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
1075
      0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
1076
      0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
1077
      0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
1078
      0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
1079
      0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
1080
      0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
1081
      0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
1082
      0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
1083
      0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
1084
      0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
1085
      0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
1086
      0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
1087
      0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
1088
      0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
1089
      0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
1090
      0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
1091
      0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
1092
      0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
1093
      0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
1094
      0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
1095
      0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
1096
      0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
1097
      0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
1098
      0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
1099
      0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
1100
      0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
1101
      0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
1102
      0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
1103
      0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
1104
      0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
1105
      0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
1106
      0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
1107
      0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
1108
      0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
1109
      0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
1110
      0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
1111
      0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
1112
      0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
1113
      0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
1114
      0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
1115
      0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
1116
      0x2d02ef8d
1117
    };
1118
  const unsigned char *end;
1119
 
1120
  crc = ~crc & 0xffffffff;
1121
  for (end = buf + len; buf < end; ++ buf)
1122
    crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8);
1123
  return ~crc & 0xffffffff;;
1124
}
1125
 
1126
 
1127
/*
1128
INTERNAL_FUNCTION
1129
        get_debug_link_info
1130
 
1131
SYNOPSIS
1132
        char *get_debug_link_info (bfd *abfd, unsigned long *crc32_out);
1133
 
1134
DESCRIPTION
1135
        fetch the filename and CRC32 value for any separate debuginfo
1136
        associated with @var{abfd}. Return NULL if no such info found,
1137
        otherwise return filename and update @var{crc32_out}.
1138
*/
1139
 
1140
static char *
1141
get_debug_link_info (bfd *abfd, unsigned long *crc32_out)
1142
{
1143
  asection *sect;
1144
  unsigned long crc32;
1145
  bfd_byte *contents;
1146
  int crc_offset;
1147
  char *name;
1148
 
1149
  BFD_ASSERT (abfd);
1150
  BFD_ASSERT (crc32_out);
1151
 
1152
  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1153
 
1154
  if (sect == NULL)
1155
    return NULL;
1156
 
1157
  if (!bfd_malloc_and_get_section (abfd, sect, &contents))
1158
    {
1159
      if (contents != NULL)
1160
        free (contents);
1161
      return NULL;
1162
    }
1163
 
1164
  /* Crc value is stored after the filename, aligned up to 4 bytes.  */
1165
  name = (char *) contents;
1166
  crc_offset = strlen (name) + 1;
1167
  crc_offset = (crc_offset + 3) & ~3;
1168
 
1169
  crc32 = bfd_get_32 (abfd, contents + crc_offset);
1170
 
1171
  *crc32_out = crc32;
1172
  return name;
1173
}
1174
 
1175
/*
1176
INTERNAL_FUNCTION
1177
        separate_debug_file_exists
1178
 
1179
SYNOPSIS
1180
        bfd_boolean separate_debug_file_exists
1181
          (char *name, unsigned long crc32);
1182
 
1183
DESCRIPTION
1184
        Checks to see if @var{name} is a file and if its contents
1185
        match @var{crc32}.
1186
*/
1187
 
1188
static bfd_boolean
1189
separate_debug_file_exists (const char *name, const unsigned long crc)
1190
{
1191
  static unsigned char buffer [8 * 1024];
1192
  unsigned long file_crc = 0;
1193
  FILE *f;
1194
  bfd_size_type count;
1195
 
1196
  BFD_ASSERT (name);
1197
 
1198
  f = real_fopen (name, FOPEN_RB);
1199
  if (f == NULL)
1200
    return FALSE;
1201
 
1202
  while ((count = fread (buffer, 1, sizeof (buffer), f)) > 0)
1203
    file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count);
1204
 
1205
  fclose (f);
1206
 
1207
  return crc == file_crc;
1208
}
1209
 
1210
 
1211
/*
1212
INTERNAL_FUNCTION
1213
        find_separate_debug_file
1214
 
1215
SYNOPSIS
1216
        char *find_separate_debug_file (bfd *abfd);
1217
 
1218
DESCRIPTION
1219
        Searches @var{abfd} for a reference to separate debugging
1220
        information, scans various locations in the filesystem, including
1221
        the file tree rooted at @var{debug_file_directory}, and returns a
1222
        filename of such debugging information if the file is found and has
1223
        matching CRC32.  Returns NULL if no reference to debugging file
1224
        exists, or file cannot be found.
1225
*/
1226
 
1227
static char *
1228
find_separate_debug_file (bfd *abfd, const char *debug_file_directory)
1229
{
1230
  char *base;
1231
  char *dir;
1232
  char *debugfile;
1233
  char *canon_dir;
1234
  unsigned long crc32;
1235
  size_t dirlen;
1236
  size_t canon_dirlen;
1237
 
1238
  BFD_ASSERT (abfd);
1239
  if (debug_file_directory == NULL)
1240
    debug_file_directory = ".";
1241
 
1242
  /* BFD may have been opened from a stream.  */
1243
  if (abfd->filename == NULL)
1244
    {
1245
      bfd_set_error (bfd_error_invalid_operation);
1246
      return NULL;
1247
    }
1248
 
1249
  base = get_debug_link_info (abfd, & crc32);
1250
  if (base == NULL)
1251
    return NULL;
1252
 
1253
  if (base[0] == '\0')
1254
    {
1255
      free (base);
1256
      bfd_set_error (bfd_error_no_debug_section);
1257
      return NULL;
1258
    }
1259
 
1260
  for (dirlen = strlen (abfd->filename); dirlen > 0; dirlen--)
1261
    if (IS_DIR_SEPARATOR (abfd->filename[dirlen - 1]))
1262
      break;
1263
 
1264
  dir = (char *) bfd_malloc (dirlen + 1);
1265
  if (dir == NULL)
1266
    {
1267
      free (base);
1268
      return NULL;
1269
    }
1270
  memcpy (dir, abfd->filename, dirlen);
1271
  dir[dirlen] = '\0';
1272
 
1273
  /* Compute the canonical name of the bfd object with all symbolic links
1274
     resolved, for use in the global debugfile directory.  */
1275
  canon_dir = lrealpath (abfd->filename);
1276
  for (canon_dirlen = strlen (canon_dir); canon_dirlen > 0; canon_dirlen--)
1277
    if (IS_DIR_SEPARATOR (canon_dir[canon_dirlen - 1]))
1278
      break;
1279
  canon_dir[canon_dirlen] = '\0';
1280
 
1281
  debugfile = (char *)
1282
      bfd_malloc (strlen (debug_file_directory) + 1
1283
                  + (canon_dirlen > dirlen ? canon_dirlen : dirlen)
1284
                  + strlen (".debug/")
1285
                  + strlen (base)
1286
                  + 1);
1287
  if (debugfile == NULL)
1288
    {
1289
      free (base);
1290
      free (dir);
1291
      free (canon_dir);
1292
      return NULL;
1293
    }
1294
 
1295
  /* First try in the same directory as the original file:  */
1296
  strcpy (debugfile, dir);
1297
  strcat (debugfile, base);
1298
 
1299
  if (separate_debug_file_exists (debugfile, crc32))
1300
    {
1301
      free (base);
1302
      free (dir);
1303
      free (canon_dir);
1304
      return debugfile;
1305
    }
1306
 
1307
  /* Then try in a subdirectory called .debug.  */
1308
  strcpy (debugfile, dir);
1309
  strcat (debugfile, ".debug/");
1310
  strcat (debugfile, base);
1311
 
1312
  if (separate_debug_file_exists (debugfile, crc32))
1313
    {
1314
      free (base);
1315
      free (dir);
1316
      free (canon_dir);
1317
      return debugfile;
1318
    }
1319
 
1320
  /* Then try in the global debugfile directory.  */
1321
  strcpy (debugfile, debug_file_directory);
1322
  dirlen = strlen (debug_file_directory) - 1;
1323
  if (dirlen > 0
1324
      && debug_file_directory[dirlen] != '/'
1325
      && canon_dir[0] != '/')
1326
    strcat (debugfile, "/");
1327
  strcat (debugfile, canon_dir);
1328
  strcat (debugfile, base);
1329
 
1330
  if (separate_debug_file_exists (debugfile, crc32))
1331
    {
1332
      free (base);
1333
      free (dir);
1334
      free (canon_dir);
1335
      return debugfile;
1336
    }
1337
 
1338
  free (debugfile);
1339
  free (base);
1340
  free (dir);
1341
  free (canon_dir);
1342
  return NULL;
1343
}
1344
 
1345
 
1346
/*
1347
FUNCTION
1348
        bfd_follow_gnu_debuglink
1349
 
1350
SYNOPSIS
1351
        char *bfd_follow_gnu_debuglink (bfd *abfd, const char *dir);
1352
 
1353
DESCRIPTION
1354
 
1355
        Takes a BFD and searches it for a .gnu_debuglink section.  If this
1356
        section is found, it examines the section for the name and checksum
1357
        of a '.debug' file containing auxiliary debugging information.  It
1358
        then searches the filesystem for this .debug file in some standard
1359
        locations, including the directory tree rooted at @var{dir}, and if
1360
        found returns the full filename.
1361
 
1362
        If @var{dir} is NULL, it will search a default path configured into
1363
        libbfd at build time.  [XXX this feature is not currently
1364
        implemented].
1365
 
1366
RETURNS
1367
        <<NULL>> on any errors or failure to locate the .debug file,
1368
        otherwise a pointer to a heap-allocated string containing the
1369
        filename.  The caller is responsible for freeing this string.
1370
*/
1371
 
1372
char *
1373
bfd_follow_gnu_debuglink (bfd *abfd, const char *dir)
1374
{
1375
  return find_separate_debug_file (abfd, dir);
1376
}
1377
 
1378
/*
1379
FUNCTION
1380
        bfd_create_gnu_debuglink_section
1381
 
1382
SYNOPSIS
1383
        struct bfd_section *bfd_create_gnu_debuglink_section
1384
          (bfd *abfd, const char *filename);
1385
 
1386
DESCRIPTION
1387
 
1388
        Takes a @var{BFD} and adds a .gnu_debuglink section to it.  The section is sized
1389
        to be big enough to contain a link to the specified @var{filename}.
1390
 
1391
RETURNS
1392
        A pointer to the new section is returned if all is ok.  Otherwise <<NULL>> is
1393
        returned and bfd_error is set.
1394
*/
1395
 
1396
asection *
1397
bfd_create_gnu_debuglink_section (bfd *abfd, const char *filename)
1398
{
1399
  asection *sect;
1400
  bfd_size_type debuglink_size;
1401
  flagword flags;
1402
 
1403
  if (abfd == NULL || filename == NULL)
1404
    {
1405
      bfd_set_error (bfd_error_invalid_operation);
1406
      return NULL;
1407
    }
1408
 
1409
  /* Strip off any path components in filename.  */
1410
  filename = lbasename (filename);
1411
 
1412
  sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK);
1413
  if (sect)
1414
    {
1415
      /* Section already exists.  */
1416
      bfd_set_error (bfd_error_invalid_operation);
1417
      return NULL;
1418
    }
1419
 
1420
  flags = SEC_HAS_CONTENTS | SEC_READONLY | SEC_DEBUGGING;
1421
  sect = bfd_make_section_with_flags (abfd, GNU_DEBUGLINK, flags);
1422
  if (sect == NULL)
1423
    return NULL;
1424
 
1425
  debuglink_size = strlen (filename) + 1;
1426
  debuglink_size += 3;
1427
  debuglink_size &= ~3;
1428
  debuglink_size += 4;
1429
 
1430
  if (! bfd_set_section_size (abfd, sect, debuglink_size))
1431
    /* XXX Should we delete the section from the bfd ?  */
1432
    return NULL;
1433
 
1434
  return sect;
1435
}
1436
 
1437
 
1438
/*
1439
FUNCTION
1440
        bfd_fill_in_gnu_debuglink_section
1441
 
1442
SYNOPSIS
1443
        bfd_boolean bfd_fill_in_gnu_debuglink_section
1444
          (bfd *abfd, struct bfd_section *sect, const char *filename);
1445
 
1446
DESCRIPTION
1447
 
1448
        Takes a @var{BFD} and containing a .gnu_debuglink section @var{SECT}
1449
        and fills in the contents of the section to contain a link to the
1450
        specified @var{filename}.  The filename should be relative to the
1451
        current directory.
1452
 
1453
RETURNS
1454
        <<TRUE>> is returned if all is ok.  Otherwise <<FALSE>> is returned
1455
        and bfd_error is set.
1456
*/
1457
 
1458
bfd_boolean
1459
bfd_fill_in_gnu_debuglink_section (bfd *abfd,
1460
                                   struct bfd_section *sect,
1461
                                   const char *filename)
1462
{
1463
  bfd_size_type debuglink_size;
1464
  unsigned long crc32;
1465
  char * contents;
1466
  bfd_size_type crc_offset;
1467
  FILE * handle;
1468
  static unsigned char buffer[8 * 1024];
1469
  size_t count;
1470
  size_t filelen;
1471
 
1472
  if (abfd == NULL || sect == NULL || filename == NULL)
1473
    {
1474
      bfd_set_error (bfd_error_invalid_operation);
1475
      return FALSE;
1476
    }
1477
 
1478
  /* Make sure that we can read the file.
1479
     XXX - Should we attempt to locate the debug info file using the same
1480
     algorithm as gdb ?  At the moment, since we are creating the
1481
     .gnu_debuglink section, we insist upon the user providing us with a
1482
     correct-for-section-creation-time path, but this need not conform to
1483
     the gdb location algorithm.  */
1484
  handle = real_fopen (filename, FOPEN_RB);
1485
  if (handle == NULL)
1486
    {
1487
      bfd_set_error (bfd_error_system_call);
1488
      return FALSE;
1489
    }
1490
 
1491
  crc32 = 0;
1492
  while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0)
1493
    crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count);
1494
  fclose (handle);
1495
 
1496
  /* Strip off any path components in filename,
1497
     now that we no longer need them.  */
1498
  filename = lbasename (filename);
1499
 
1500
  filelen = strlen (filename);
1501
  debuglink_size = filelen + 1;
1502
  debuglink_size += 3;
1503
  debuglink_size &= ~3;
1504
  debuglink_size += 4;
1505
 
1506
  contents = (char *) bfd_malloc (debuglink_size);
1507
  if (contents == NULL)
1508
    {
1509
      /* XXX Should we delete the section from the bfd ?  */
1510
      return FALSE;
1511
    }
1512
 
1513
  crc_offset = debuglink_size - 4;
1514
  memcpy (contents, filename, filelen);
1515
  memset (contents + filelen, 0, crc_offset - filelen);
1516
 
1517
  bfd_put_32 (abfd, crc32, contents + crc_offset);
1518
 
1519
  if (! bfd_set_section_contents (abfd, sect, contents, 0, debuglink_size))
1520
    {
1521
      /* XXX Should we delete the section from the bfd ?  */
1522
      free (contents);
1523
      return FALSE;
1524
    }
1525
 
1526
  return TRUE;
1527
}

powered by: WebSVN 2.1.0

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