Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* opncls.c -- open and close a BFD. |
7898deda | 2 | Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2000, |
31f7ba04 | 3 | 2001, 2002, 2003 |
252b5132 RH |
4 | Free Software Foundation, Inc. |
5 | ||
6 | Written by Cygnus Support. | |
7 | ||
c4f3d130 | 8 | This file is part of BFD, the Binary File Descriptor library. |
252b5132 | 9 | |
c4f3d130 NC |
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 2 of the License, or | |
13 | (at your option) any later version. | |
252b5132 | 14 | |
c4f3d130 NC |
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. | |
252b5132 | 19 | |
c4f3d130 NC |
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
252b5132 RH |
23 | |
24 | #include "bfd.h" | |
25 | #include "sysdep.h" | |
26 | #include "objalloc.h" | |
27 | #include "libbfd.h" | |
31f7ba04 | 28 | #include "libiberty.h" |
252b5132 RH |
29 | |
30 | #ifndef S_IXUSR | |
31 | #define S_IXUSR 0100 /* Execute by owner. */ | |
32 | #endif | |
33 | #ifndef S_IXGRP | |
34 | #define S_IXGRP 0010 /* Execute by group. */ | |
35 | #endif | |
36 | #ifndef S_IXOTH | |
37 | #define S_IXOTH 0001 /* Execute by others. */ | |
38 | #endif | |
39 | ||
52b69c9e AO |
40 | /* Counter used to initialize the bfd identifier. */ |
41 | ||
42 | static unsigned int _bfd_id_counter = 0; | |
43 | ||
252b5132 RH |
44 | /* fdopen is a loser -- we should use stdio exclusively. Unfortunately |
45 | if we do that we can't use fcntl. */ | |
46 | ||
252b5132 RH |
47 | /* Return a new BFD. All BFD's are allocated through this routine. */ |
48 | ||
49 | bfd * | |
50 | _bfd_new_bfd () | |
51 | { | |
52 | bfd *nbfd; | |
53 | ||
dc810e39 | 54 | nbfd = (bfd *) bfd_zmalloc ((bfd_size_type) sizeof (bfd)); |
252b5132 RH |
55 | if (nbfd == NULL) |
56 | return NULL; | |
57 | ||
52b69c9e AO |
58 | nbfd->id = _bfd_id_counter++; |
59 | ||
252b5132 RH |
60 | nbfd->memory = (PTR) objalloc_create (); |
61 | if (nbfd->memory == NULL) | |
62 | { | |
63 | bfd_set_error (bfd_error_no_memory); | |
73e87d70 | 64 | free (nbfd); |
252b5132 RH |
65 | return NULL; |
66 | } | |
67 | ||
68 | nbfd->arch_info = &bfd_default_arch_struct; | |
69 | ||
70 | nbfd->direction = no_direction; | |
71 | nbfd->iostream = NULL; | |
72 | nbfd->where = 0; | |
7c4a37eb AM |
73 | if (!bfd_hash_table_init_n (&nbfd->section_htab, |
74 | bfd_section_hash_newfunc, | |
75 | 251)) | |
73e87d70 AM |
76 | { |
77 | free (nbfd); | |
78 | return NULL; | |
79 | } | |
252b5132 | 80 | nbfd->sections = (asection *) NULL; |
73e87d70 | 81 | nbfd->section_tail = &nbfd->sections; |
252b5132 RH |
82 | nbfd->format = bfd_unknown; |
83 | nbfd->my_archive = (bfd *) NULL; | |
dc810e39 | 84 | nbfd->origin = 0; |
b34976b6 AM |
85 | nbfd->opened_once = FALSE; |
86 | nbfd->output_has_begun = FALSE; | |
252b5132 RH |
87 | nbfd->section_count = 0; |
88 | nbfd->usrdata = (PTR) NULL; | |
b34976b6 | 89 | nbfd->cacheable = FALSE; |
252b5132 | 90 | nbfd->flags = BFD_NO_FLAGS; |
b34976b6 | 91 | nbfd->mtime_set = FALSE; |
252b5132 RH |
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 (obfd) | |
100 | bfd *obfd; | |
101 | { | |
102 | bfd *nbfd; | |
103 | ||
104 | nbfd = _bfd_new_bfd (); | |
301e3139 AM |
105 | if (nbfd == NULL) |
106 | return NULL; | |
252b5132 RH |
107 | nbfd->xvec = obfd->xvec; |
108 | nbfd->my_archive = obfd; | |
109 | nbfd->direction = read_direction; | |
110 | nbfd->target_defaulted = obfd->target_defaulted; | |
111 | return nbfd; | |
112 | } | |
113 | ||
73e87d70 AM |
114 | /* Delete a BFD. */ |
115 | ||
116 | void | |
117 | _bfd_delete_bfd (abfd) | |
118 | bfd *abfd; | |
119 | { | |
120 | bfd_hash_table_free (&abfd->section_htab); | |
121 | objalloc_free ((struct objalloc *) abfd->memory); | |
122 | free (abfd); | |
123 | } | |
124 | ||
252b5132 RH |
125 | /* |
126 | SECTION | |
127 | Opening and closing BFDs | |
128 | ||
129 | */ | |
130 | ||
131 | /* | |
132 | FUNCTION | |
133 | bfd_openr | |
134 | ||
135 | SYNOPSIS | |
7c4a37eb | 136 | bfd *bfd_openr(const char *filename, const char *target); |
252b5132 RH |
137 | |
138 | DESCRIPTION | |
139 | Open the file @var{filename} (using <<fopen>>) with the target | |
140 | @var{target}. Return a pointer to the created BFD. | |
141 | ||
142 | Calls <<bfd_find_target>>, so @var{target} is interpreted as by | |
143 | that function. | |
144 | ||
145 | If <<NULL>> is returned then an error has occured. Possible errors | |
7c4a37eb AM |
146 | are <<bfd_error_no_memory>>, <<bfd_error_invalid_target>> or |
147 | <<system_call>> error. | |
252b5132 RH |
148 | */ |
149 | ||
150 | bfd * | |
151 | bfd_openr (filename, target) | |
dc810e39 AM |
152 | const char *filename; |
153 | const char *target; | |
252b5132 RH |
154 | { |
155 | bfd *nbfd; | |
156 | const bfd_target *target_vec; | |
157 | ||
158 | nbfd = _bfd_new_bfd (); | |
159 | if (nbfd == NULL) | |
160 | return NULL; | |
161 | ||
162 | target_vec = bfd_find_target (target, nbfd); | |
163 | if (target_vec == NULL) | |
164 | { | |
73e87d70 | 165 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
166 | return NULL; |
167 | } | |
168 | ||
169 | nbfd->filename = filename; | |
170 | nbfd->direction = read_direction; | |
171 | ||
172 | if (bfd_open_file (nbfd) == NULL) | |
173 | { | |
c4f3d130 | 174 | /* File didn't exist, or some such. */ |
252b5132 | 175 | bfd_set_error (bfd_error_system_call); |
73e87d70 | 176 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
177 | return NULL; |
178 | } | |
179 | ||
180 | return nbfd; | |
181 | } | |
182 | ||
183 | /* Don't try to `optimize' this function: | |
184 | ||
185 | o - We lock using stack space so that interrupting the locking | |
186 | won't cause a storage leak. | |
187 | o - We open the file stream last, since we don't want to have to | |
188 | close it if anything goes wrong. Closing the stream means closing | |
c4f3d130 | 189 | the file descriptor too, even though we didn't open it. */ |
252b5132 RH |
190 | /* |
191 | FUNCTION | |
7c4a37eb | 192 | bfd_fdopenr |
252b5132 RH |
193 | |
194 | SYNOPSIS | |
7c4a37eb | 195 | bfd *bfd_fdopenr(const char *filename, const char *target, int fd); |
252b5132 RH |
196 | |
197 | DESCRIPTION | |
7c4a37eb AM |
198 | <<bfd_fdopenr>> is to <<bfd_fopenr>> much like <<fdopen>> is to |
199 | <<fopen>>. It opens a BFD on a file already described by the | |
200 | @var{fd} supplied. | |
201 | ||
202 | When the file is later <<bfd_close>>d, the file descriptor will | |
203 | be closed. If the caller desires that this file descriptor be | |
204 | cached by BFD (opened as needed, closed as needed to free | |
205 | descriptors for other opens), with the supplied @var{fd} used as | |
206 | an initial file descriptor (but subject to closure at any time), | |
207 | call bfd_set_cacheable(bfd, 1) on the returned BFD. The default | |
208 | is to assume no cacheing; the file descriptor will remain open | |
209 | until <<bfd_close>>, and will not be affected by BFD operations | |
210 | on other files. | |
211 | ||
212 | Possible errors are <<bfd_error_no_memory>>, | |
213 | <<bfd_error_invalid_target>> and <<bfd_error_system_call>>. | |
252b5132 RH |
214 | */ |
215 | ||
216 | bfd * | |
217 | bfd_fdopenr (filename, target, fd) | |
dc810e39 AM |
218 | const char *filename; |
219 | const char *target; | |
252b5132 RH |
220 | int fd; |
221 | { | |
222 | bfd *nbfd; | |
223 | const bfd_target *target_vec; | |
224 | int fdflags; | |
225 | ||
226 | bfd_set_error (bfd_error_system_call); | |
227 | #if ! defined(HAVE_FCNTL) || ! defined(F_GETFL) | |
c4f3d130 | 228 | fdflags = O_RDWR; /* Assume full access. */ |
252b5132 RH |
229 | #else |
230 | fdflags = fcntl (fd, F_GETFL, NULL); | |
231 | #endif | |
767e34d1 AM |
232 | if (fdflags == -1) |
233 | return NULL; | |
252b5132 RH |
234 | |
235 | nbfd = _bfd_new_bfd (); | |
236 | if (nbfd == NULL) | |
237 | return NULL; | |
238 | ||
239 | target_vec = bfd_find_target (target, nbfd); | |
240 | if (target_vec == NULL) | |
241 | { | |
73e87d70 | 242 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
243 | return NULL; |
244 | } | |
245 | ||
246 | #ifndef HAVE_FDOPEN | |
247 | nbfd->iostream = (PTR) fopen (filename, FOPEN_RB); | |
248 | #else | |
c4f3d130 | 249 | /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */ |
252b5132 RH |
250 | switch (fdflags & (O_ACCMODE)) |
251 | { | |
252 | case O_RDONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RB); break; | |
253 | case O_WRONLY: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB); break; | |
254 | case O_RDWR: nbfd->iostream = (PTR) fdopen (fd, FOPEN_RUB); break; | |
255 | default: abort (); | |
256 | } | |
257 | #endif | |
258 | ||
259 | if (nbfd->iostream == NULL) | |
260 | { | |
73e87d70 | 261 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
262 | return NULL; |
263 | } | |
264 | ||
c4f3d130 | 265 | /* OK, put everything where it belongs. */ |
252b5132 RH |
266 | nbfd->filename = filename; |
267 | ||
268 | /* As a special case we allow a FD open for read/write to | |
269 | be written through, although doing so requires that we end | |
270 | the previous clause with a preposition. */ | |
c4f3d130 | 271 | /* (O_ACCMODE) parens are to avoid Ultrix header file bug. */ |
d768008d | 272 | switch (fdflags & (O_ACCMODE)) |
252b5132 RH |
273 | { |
274 | case O_RDONLY: nbfd->direction = read_direction; break; | |
275 | case O_WRONLY: nbfd->direction = write_direction; break; | |
276 | case O_RDWR: nbfd->direction = both_direction; break; | |
277 | default: abort (); | |
278 | } | |
279 | ||
280 | if (! bfd_cache_init (nbfd)) | |
281 | { | |
73e87d70 | 282 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
283 | return NULL; |
284 | } | |
b34976b6 | 285 | nbfd->opened_once = TRUE; |
252b5132 RH |
286 | |
287 | return nbfd; | |
288 | } | |
289 | ||
290 | /* | |
291 | FUNCTION | |
292 | bfd_openstreamr | |
293 | ||
294 | SYNOPSIS | |
295 | bfd *bfd_openstreamr(const char *, const char *, PTR); | |
296 | ||
297 | DESCRIPTION | |
298 | ||
299 | Open a BFD for read access on an existing stdio stream. When | |
300 | the BFD is passed to <<bfd_close>>, the stream will be closed. | |
301 | */ | |
302 | ||
303 | bfd * | |
304 | bfd_openstreamr (filename, target, streamarg) | |
305 | const char *filename; | |
306 | const char *target; | |
307 | PTR streamarg; | |
308 | { | |
309 | FILE *stream = (FILE *) streamarg; | |
310 | bfd *nbfd; | |
311 | const bfd_target *target_vec; | |
312 | ||
313 | nbfd = _bfd_new_bfd (); | |
314 | if (nbfd == NULL) | |
315 | return NULL; | |
316 | ||
317 | target_vec = bfd_find_target (target, nbfd); | |
318 | if (target_vec == NULL) | |
319 | { | |
73e87d70 | 320 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
321 | return NULL; |
322 | } | |
323 | ||
324 | nbfd->iostream = (PTR) stream; | |
325 | nbfd->filename = filename; | |
326 | nbfd->direction = read_direction; | |
dc810e39 | 327 | |
252b5132 RH |
328 | if (! bfd_cache_init (nbfd)) |
329 | { | |
73e87d70 | 330 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
331 | return NULL; |
332 | } | |
333 | ||
334 | return nbfd; | |
335 | } | |
336 | \f | |
c4f3d130 NC |
337 | /* bfd_openw -- open for writing. |
338 | Returns a pointer to a freshly-allocated BFD on success, or NULL. | |
252b5132 | 339 | |
c4f3d130 | 340 | See comment by bfd_fdopenr before you try to modify this function. */ |
252b5132 RH |
341 | |
342 | /* | |
343 | FUNCTION | |
344 | bfd_openw | |
345 | ||
346 | SYNOPSIS | |
dc810e39 | 347 | bfd *bfd_openw(const char *filename, const char *target); |
252b5132 RH |
348 | |
349 | DESCRIPTION | |
350 | Create a BFD, associated with file @var{filename}, using the | |
351 | file format @var{target}, and return a pointer to it. | |
352 | ||
353 | Possible errors are <<bfd_error_system_call>>, <<bfd_error_no_memory>>, | |
354 | <<bfd_error_invalid_target>>. | |
355 | */ | |
356 | ||
357 | bfd * | |
358 | bfd_openw (filename, target) | |
dc810e39 AM |
359 | const char *filename; |
360 | const char *target; | |
252b5132 RH |
361 | { |
362 | bfd *nbfd; | |
363 | const bfd_target *target_vec; | |
364 | ||
252b5132 | 365 | /* nbfd has to point to head of malloc'ed block so that bfd_close may |
c4f3d130 | 366 | reclaim it correctly. */ |
252b5132 RH |
367 | nbfd = _bfd_new_bfd (); |
368 | if (nbfd == NULL) | |
369 | return NULL; | |
370 | ||
371 | target_vec = bfd_find_target (target, nbfd); | |
372 | if (target_vec == NULL) | |
373 | { | |
73e87d70 | 374 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
375 | return NULL; |
376 | } | |
377 | ||
378 | nbfd->filename = filename; | |
379 | nbfd->direction = write_direction; | |
380 | ||
381 | if (bfd_open_file (nbfd) == NULL) | |
382 | { | |
c4f3d130 NC |
383 | /* File not writeable, etc. */ |
384 | bfd_set_error (bfd_error_system_call); | |
73e87d70 | 385 | _bfd_delete_bfd (nbfd); |
252b5132 RH |
386 | return NULL; |
387 | } | |
388 | ||
389 | return nbfd; | |
390 | } | |
391 | ||
392 | /* | |
393 | ||
394 | FUNCTION | |
395 | bfd_close | |
396 | ||
397 | SYNOPSIS | |
b34976b6 | 398 | bfd_boolean bfd_close (bfd *abfd); |
252b5132 RH |
399 | |
400 | DESCRIPTION | |
401 | ||
7c4a37eb AM |
402 | Close a BFD. If the BFD was open for writing, then pending |
403 | operations are completed and the file written out and closed. | |
404 | If the created file is executable, then <<chmod>> is called | |
405 | to mark it as such. | |
252b5132 RH |
406 | |
407 | All memory attached to the BFD is released. | |
408 | ||
409 | The file descriptor associated with the BFD is closed (even | |
410 | if it was passed in to BFD by <<bfd_fdopenr>>). | |
411 | ||
412 | RETURNS | |
b34976b6 | 413 | <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. |
252b5132 RH |
414 | */ |
415 | ||
416 | ||
b34976b6 | 417 | bfd_boolean |
252b5132 RH |
418 | bfd_close (abfd) |
419 | bfd *abfd; | |
420 | { | |
b34976b6 | 421 | bfd_boolean ret; |
252b5132 | 422 | |
c4f3d130 | 423 | if (bfd_write_p (abfd)) |
252b5132 RH |
424 | { |
425 | if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) | |
b34976b6 | 426 | return FALSE; |
252b5132 RH |
427 | } |
428 | ||
429 | if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) | |
b34976b6 | 430 | return FALSE; |
252b5132 RH |
431 | |
432 | ret = bfd_cache_close (abfd); | |
433 | ||
434 | /* If the file was open for writing and is now executable, | |
c4f3d130 | 435 | make it so. */ |
252b5132 RH |
436 | if (ret |
437 | && abfd->direction == write_direction | |
438 | && abfd->flags & EXEC_P) | |
439 | { | |
440 | struct stat buf; | |
441 | ||
442 | if (stat (abfd->filename, &buf) == 0) | |
443 | { | |
7c4a37eb | 444 | unsigned int mask = umask (0); |
c4f3d130 | 445 | |
252b5132 RH |
446 | umask (mask); |
447 | chmod (abfd->filename, | |
448 | (0777 | |
449 | & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); | |
450 | } | |
451 | } | |
452 | ||
73e87d70 | 453 | _bfd_delete_bfd (abfd); |
252b5132 RH |
454 | |
455 | return ret; | |
456 | } | |
457 | ||
458 | /* | |
459 | FUNCTION | |
460 | bfd_close_all_done | |
461 | ||
462 | SYNOPSIS | |
b34976b6 | 463 | bfd_boolean bfd_close_all_done (bfd *); |
252b5132 RH |
464 | |
465 | DESCRIPTION | |
7c4a37eb AM |
466 | Close a BFD. Differs from <<bfd_close>> since it does not |
467 | complete any pending operations. This routine would be used | |
468 | if the application had just used BFD for swapping and didn't | |
469 | want to use any of the writing code. | |
252b5132 RH |
470 | |
471 | If the created file is executable, then <<chmod>> is called | |
472 | to mark it as such. | |
473 | ||
474 | All memory attached to the BFD is released. | |
475 | ||
476 | RETURNS | |
b34976b6 | 477 | <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. |
252b5132 RH |
478 | */ |
479 | ||
b34976b6 | 480 | bfd_boolean |
252b5132 RH |
481 | bfd_close_all_done (abfd) |
482 | bfd *abfd; | |
483 | { | |
b34976b6 | 484 | bfd_boolean ret; |
252b5132 RH |
485 | |
486 | ret = bfd_cache_close (abfd); | |
487 | ||
488 | /* If the file was open for writing and is now executable, | |
c4f3d130 | 489 | make it so. */ |
252b5132 RH |
490 | if (ret |
491 | && abfd->direction == write_direction | |
492 | && abfd->flags & EXEC_P) | |
493 | { | |
494 | struct stat buf; | |
495 | ||
496 | if (stat (abfd->filename, &buf) == 0) | |
497 | { | |
dc810e39 | 498 | unsigned int mask = umask (0); |
c4f3d130 | 499 | |
252b5132 RH |
500 | umask (mask); |
501 | chmod (abfd->filename, | |
b6cdd0fd | 502 | (0777 |
252b5132 RH |
503 | & (buf.st_mode | ((S_IXUSR | S_IXGRP | S_IXOTH) &~ mask)))); |
504 | } | |
505 | } | |
506 | ||
73e87d70 | 507 | _bfd_delete_bfd (abfd); |
252b5132 RH |
508 | |
509 | return ret; | |
510 | } | |
511 | ||
512 | /* | |
513 | FUNCTION | |
514 | bfd_create | |
515 | ||
516 | SYNOPSIS | |
dc810e39 | 517 | bfd *bfd_create(const char *filename, bfd *templ); |
252b5132 RH |
518 | |
519 | DESCRIPTION | |
7c4a37eb AM |
520 | Create a new BFD in the manner of <<bfd_openw>>, but without |
521 | opening a file. The new BFD takes the target from the target | |
522 | used by @var{template}. The format is always set to <<bfd_object>>. | |
252b5132 RH |
523 | */ |
524 | ||
525 | bfd * | |
526 | bfd_create (filename, templ) | |
dc810e39 | 527 | const char *filename; |
252b5132 RH |
528 | bfd *templ; |
529 | { | |
530 | bfd *nbfd; | |
531 | ||
532 | nbfd = _bfd_new_bfd (); | |
533 | if (nbfd == NULL) | |
534 | return NULL; | |
535 | nbfd->filename = filename; | |
536 | if (templ) | |
537 | nbfd->xvec = templ->xvec; | |
538 | nbfd->direction = no_direction; | |
539 | bfd_set_format (nbfd, bfd_object); | |
c4f3d130 | 540 | |
252b5132 RH |
541 | return nbfd; |
542 | } | |
543 | ||
544 | /* | |
545 | FUNCTION | |
546 | bfd_make_writable | |
547 | ||
548 | SYNOPSIS | |
b34976b6 | 549 | bfd_boolean bfd_make_writable (bfd *abfd); |
252b5132 RH |
550 | |
551 | DESCRIPTION | |
552 | Takes a BFD as created by <<bfd_create>> and converts it | |
553 | into one like as returned by <<bfd_openw>>. It does this | |
554 | by converting the BFD to BFD_IN_MEMORY. It's assumed that | |
555 | you will call <<bfd_make_readable>> on this bfd later. | |
556 | ||
557 | RETURNS | |
b34976b6 | 558 | <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. |
252b5132 RH |
559 | */ |
560 | ||
b34976b6 | 561 | bfd_boolean |
252b5132 RH |
562 | bfd_make_writable(abfd) |
563 | bfd *abfd; | |
564 | { | |
565 | struct bfd_in_memory *bim; | |
566 | ||
567 | if (abfd->direction != no_direction) | |
568 | { | |
569 | bfd_set_error (bfd_error_invalid_operation); | |
b34976b6 | 570 | return FALSE; |
252b5132 RH |
571 | } |
572 | ||
dc810e39 AM |
573 | bim = ((struct bfd_in_memory *) |
574 | bfd_malloc ((bfd_size_type) sizeof (struct bfd_in_memory))); | |
252b5132 | 575 | abfd->iostream = (PTR) bim; |
c4f3d130 | 576 | /* bfd_bwrite will grow these as needed. */ |
252b5132 RH |
577 | bim->size = 0; |
578 | bim->buffer = 0; | |
579 | ||
580 | abfd->flags |= BFD_IN_MEMORY; | |
581 | abfd->direction = write_direction; | |
582 | abfd->where = 0; | |
583 | ||
b34976b6 | 584 | return TRUE; |
252b5132 RH |
585 | } |
586 | ||
587 | /* | |
588 | FUNCTION | |
589 | bfd_make_readable | |
590 | ||
591 | SYNOPSIS | |
b34976b6 | 592 | bfd_boolean bfd_make_readable (bfd *abfd); |
252b5132 RH |
593 | |
594 | DESCRIPTION | |
595 | Takes a BFD as created by <<bfd_create>> and | |
596 | <<bfd_make_writable>> and converts it into one like as | |
597 | returned by <<bfd_openr>>. It does this by writing the | |
598 | contents out to the memory buffer, then reversing the | |
599 | direction. | |
600 | ||
601 | RETURNS | |
b34976b6 | 602 | <<TRUE>> is returned if all is ok, otherwise <<FALSE>>. */ |
252b5132 | 603 | |
b34976b6 | 604 | bfd_boolean |
252b5132 RH |
605 | bfd_make_readable(abfd) |
606 | bfd *abfd; | |
607 | { | |
608 | if (abfd->direction != write_direction || !(abfd->flags & BFD_IN_MEMORY)) | |
609 | { | |
610 | bfd_set_error (bfd_error_invalid_operation); | |
b34976b6 | 611 | return FALSE; |
252b5132 RH |
612 | } |
613 | ||
614 | if (! BFD_SEND_FMT (abfd, _bfd_write_contents, (abfd))) | |
b34976b6 | 615 | return FALSE; |
252b5132 RH |
616 | |
617 | if (! BFD_SEND (abfd, _close_and_cleanup, (abfd))) | |
b34976b6 | 618 | return FALSE; |
252b5132 RH |
619 | |
620 | ||
621 | abfd->arch_info = &bfd_default_arch_struct; | |
622 | ||
623 | abfd->where = 0; | |
252b5132 RH |
624 | abfd->format = bfd_unknown; |
625 | abfd->my_archive = (bfd *) NULL; | |
dc810e39 | 626 | abfd->origin = 0; |
b34976b6 AM |
627 | abfd->opened_once = FALSE; |
628 | abfd->output_has_begun = FALSE; | |
252b5132 RH |
629 | abfd->section_count = 0; |
630 | abfd->usrdata = (PTR) NULL; | |
b34976b6 | 631 | abfd->cacheable = FALSE; |
252b5132 | 632 | abfd->flags = BFD_IN_MEMORY; |
b34976b6 | 633 | abfd->mtime_set = FALSE; |
252b5132 | 634 | |
b34976b6 | 635 | abfd->target_defaulted = TRUE; |
252b5132 RH |
636 | abfd->direction = read_direction; |
637 | abfd->sections = 0; | |
638 | abfd->symcount = 0; | |
639 | abfd->outsymbols = 0; | |
640 | abfd->tdata.any = 0; | |
641 | ||
e54fdaa5 AM |
642 | bfd_section_list_clear (abfd); |
643 | bfd_check_format (abfd, bfd_object); | |
252b5132 | 644 | |
b34976b6 | 645 | return TRUE; |
252b5132 RH |
646 | } |
647 | ||
648 | /* | |
649 | INTERNAL_FUNCTION | |
650 | bfd_alloc | |
651 | ||
652 | SYNOPSIS | |
653 | PTR bfd_alloc (bfd *abfd, size_t wanted); | |
654 | ||
655 | DESCRIPTION | |
656 | Allocate a block of @var{wanted} bytes of memory attached to | |
657 | <<abfd>> and return a pointer to it. | |
658 | */ | |
659 | ||
660 | ||
661 | PTR | |
662 | bfd_alloc (abfd, size) | |
663 | bfd *abfd; | |
dc810e39 | 664 | bfd_size_type size; |
252b5132 RH |
665 | { |
666 | PTR ret; | |
667 | ||
dc810e39 AM |
668 | if (size != (unsigned long) size) |
669 | { | |
670 | bfd_set_error (bfd_error_no_memory); | |
671 | return NULL; | |
672 | } | |
673 | ||
252b5132 RH |
674 | ret = objalloc_alloc (abfd->memory, (unsigned long) size); |
675 | if (ret == NULL) | |
676 | bfd_set_error (bfd_error_no_memory); | |
677 | return ret; | |
678 | } | |
679 | ||
680 | PTR | |
681 | bfd_zalloc (abfd, size) | |
682 | bfd *abfd; | |
dc810e39 | 683 | bfd_size_type size; |
252b5132 RH |
684 | { |
685 | PTR res; | |
686 | ||
687 | res = bfd_alloc (abfd, size); | |
688 | if (res) | |
dc810e39 | 689 | memset (res, 0, (size_t) size); |
252b5132 RH |
690 | return res; |
691 | } | |
692 | ||
73e87d70 AM |
693 | /* Free a block allocated for a BFD. |
694 | Note: Also frees all more recently allocated blocks! */ | |
252b5132 RH |
695 | |
696 | void | |
697 | bfd_release (abfd, block) | |
698 | bfd *abfd; | |
699 | PTR block; | |
700 | { | |
701 | objalloc_free_block ((struct objalloc *) abfd->memory, block); | |
702 | } | |
31f7ba04 NC |
703 | |
704 | ||
705 | /* | |
706 | GNU Extension: separate debug-info files | |
707 | ||
708 | The idea here is that a special section called .gnu_debuglink might be | |
709 | embedded in a binary file, which indicates that some *other* file | |
710 | contains the real debugging information. This special section contains a | |
711 | filename and CRC32 checksum, which we read and resolve to another file, | |
712 | if it exists. | |
713 | ||
714 | This facilitates "optional" provision of debugging information, without | |
715 | having to provide two complete copies of every binary object (with and | |
716 | without debug symbols). | |
717 | */ | |
718 | ||
31f7ba04 NC |
719 | static char * get_debug_link_info PARAMS ((bfd *, unsigned long *)); |
720 | static bfd_boolean separate_debug_file_exists PARAMS ((const char *, const unsigned long)); | |
721 | static char * find_separate_debug_file PARAMS ((bfd *, const char *)); | |
722 | ||
2593f09a | 723 | #define GNU_DEBUGLINK ".gnu_debuglink" |
31f7ba04 | 724 | /* |
2593f09a NC |
725 | FUNCTION |
726 | bfd_calc_gnu_debuglink_crc32 | |
31f7ba04 NC |
727 | |
728 | SYNOPSIS | |
2593f09a | 729 | unsigned long bfd_calc_gnu_debuglink_crc32 (unsigned long crc, const unsigned char *buf, bfd_size_type len); |
31f7ba04 NC |
730 | |
731 | DESCRIPTION | |
2593f09a NC |
732 | Computes a CRC value as used in the .gnu_debuglink section. |
733 | Advances the previously computed @var{crc} value by computing | |
734 | and adding in the crc32 for @var{len} bytes of @var{buf}. | |
735 | ||
736 | RETURNS | |
737 | Return the updated CRC32 value. | |
31f7ba04 NC |
738 | */ |
739 | ||
2593f09a NC |
740 | unsigned long |
741 | bfd_calc_gnu_debuglink_crc32 (crc, buf, len) | |
31f7ba04 NC |
742 | unsigned long crc; |
743 | const unsigned char *buf; | |
2593f09a | 744 | bfd_size_type len; |
31f7ba04 NC |
745 | { |
746 | static const unsigned long crc32_table[256] = | |
747 | { | |
748 | 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, | |
749 | 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, | |
750 | 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, | |
751 | 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, | |
752 | 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, | |
753 | 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, | |
754 | 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, | |
755 | 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, | |
756 | 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, | |
757 | 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, | |
758 | 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, | |
759 | 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, | |
760 | 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, | |
761 | 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, | |
762 | 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, | |
763 | 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, | |
764 | 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, | |
765 | 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, | |
766 | 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, | |
767 | 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, | |
768 | 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, | |
769 | 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, | |
770 | 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, | |
771 | 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, | |
772 | 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, | |
773 | 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, | |
774 | 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, | |
775 | 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, | |
776 | 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, | |
777 | 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, | |
778 | 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, | |
779 | 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, | |
780 | 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, | |
781 | 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, | |
782 | 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, | |
783 | 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, | |
784 | 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, | |
785 | 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, | |
786 | 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, | |
787 | 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, | |
788 | 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, | |
789 | 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, | |
790 | 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, | |
791 | 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, | |
792 | 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, | |
793 | 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, | |
794 | 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, | |
795 | 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, | |
796 | 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, | |
797 | 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, | |
798 | 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, | |
799 | 0x2d02ef8d | |
800 | }; | |
801 | const unsigned char *end; | |
802 | ||
803 | crc = ~crc & 0xffffffff; | |
804 | for (end = buf + len; buf < end; ++ buf) | |
805 | crc = crc32_table[(crc ^ *buf) & 0xff] ^ (crc >> 8); | |
806 | return ~crc & 0xffffffff;; | |
807 | } | |
808 | ||
809 | ||
810 | /* | |
811 | INTERNAL_FUNCTION | |
812 | get_debug_link_info | |
813 | ||
814 | SYNOPSIS | |
2593f09a | 815 | char * get_debug_link_info (bfd * abfd, unsigned long * crc32_out) |
31f7ba04 NC |
816 | |
817 | DESCRIPTION | |
818 | fetch the filename and CRC32 value for any separate debuginfo | |
819 | associated with @var{abfd}. Return NULL if no such info found, | |
820 | otherwise return filename and update @var{crc32_out}. | |
821 | */ | |
822 | ||
823 | static char * | |
824 | get_debug_link_info (abfd, crc32_out) | |
2593f09a NC |
825 | bfd * abfd; |
826 | unsigned long * crc32_out; | |
31f7ba04 NC |
827 | { |
828 | asection * sect; | |
829 | bfd_size_type debuglink_size; | |
830 | unsigned long crc32; | |
831 | char * contents; | |
832 | int crc_offset; | |
833 | bfd_boolean ret; | |
834 | ||
835 | BFD_ASSERT (abfd); | |
836 | BFD_ASSERT (crc32_out); | |
837 | ||
2593f09a | 838 | sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); |
31f7ba04 NC |
839 | |
840 | if (sect == NULL) | |
841 | return NULL; | |
842 | ||
843 | debuglink_size = bfd_section_size (abfd, sect); | |
844 | ||
2593f09a NC |
845 | contents = malloc (debuglink_size); |
846 | if (contents == NULL) | |
847 | return NULL; | |
848 | ||
31f7ba04 NC |
849 | ret = bfd_get_section_contents (abfd, sect, contents, |
850 | (file_ptr)0, debuglink_size); | |
851 | if (! ret) | |
852 | { | |
853 | free (contents); | |
854 | return NULL; | |
855 | } | |
856 | ||
857 | /* Crc value is stored after the filename, aligned up to 4 bytes. */ | |
858 | crc_offset = strlen (contents) + 1; | |
859 | crc_offset = (crc_offset + 3) & ~3; | |
860 | ||
861 | crc32 = bfd_get_32 (abfd, (bfd_byte *) (contents + crc_offset)); | |
862 | ||
863 | *crc32_out = crc32; | |
864 | return contents; | |
865 | } | |
866 | ||
867 | /* | |
868 | INTERNAL_FUNCTION | |
869 | separate_debug_file_exists | |
870 | ||
871 | SYNOPSIS | |
872 | bfd_boolean separate_debug_file_exists (char * name, unsigned long crc32) | |
873 | ||
874 | DESCRIPTION | |
875 | Checks to see if @var{name} is a file and if its contents | |
876 | match @var{crc32}. | |
877 | */ | |
878 | ||
879 | static bfd_boolean | |
880 | separate_debug_file_exists (name, crc) | |
881 | const char *name; | |
882 | const unsigned long crc; | |
883 | { | |
884 | static char buffer [8 * 1024]; | |
885 | unsigned long file_crc = 0; | |
886 | int fd; | |
2593f09a | 887 | bfd_size_type count; |
31f7ba04 NC |
888 | |
889 | BFD_ASSERT (name); | |
890 | ||
891 | fd = open (name, O_RDONLY); | |
892 | if (fd < 0) | |
893 | return FALSE; | |
894 | ||
895 | while ((count = read (fd, buffer, sizeof (buffer))) > 0) | |
2593f09a | 896 | file_crc = bfd_calc_gnu_debuglink_crc32 (file_crc, buffer, count); |
31f7ba04 NC |
897 | |
898 | close (fd); | |
899 | ||
900 | return crc == file_crc; | |
901 | } | |
902 | ||
903 | ||
904 | /* | |
905 | INTERNAL_FUNCTION | |
906 | find_separate_debug_file | |
907 | ||
908 | SYNOPSIS | |
909 | char * find_separate_debug_file (bfd *abfd) | |
910 | ||
911 | DESCRIPTION | |
912 | Searches @var{abfd} for a reference to separate debugging | |
913 | information, scans various locations in the filesystem, including | |
914 | the file tree rooted at @var{debug_file_directory}, and returns a | |
915 | filename of such debugging information if the file is found and has | |
916 | matching CRC32. Returns NULL if no reference to debugging file | |
917 | exists, or file cannot be found. | |
918 | */ | |
919 | ||
920 | static char * | |
921 | find_separate_debug_file (abfd, debug_file_directory) | |
922 | bfd *abfd; | |
923 | const char *debug_file_directory; | |
924 | { | |
925 | char *basename; | |
926 | char *dir; | |
927 | char *debugfile; | |
928 | unsigned long crc32; | |
929 | int i; | |
930 | ||
931 | BFD_ASSERT (abfd); | |
932 | if (debug_file_directory == NULL) | |
933 | debug_file_directory = "."; | |
934 | ||
935 | /* BFD may have been opened from a stream. */ | |
936 | if (! abfd->filename) | |
937 | return NULL; | |
938 | ||
939 | basename = get_debug_link_info (abfd, & crc32); | |
5ed6aba4 | 940 | if (basename == NULL) |
31f7ba04 | 941 | return NULL; |
2593f09a | 942 | |
5ed6aba4 NC |
943 | if (strlen (basename) < 1) |
944 | { | |
945 | free (basename); | |
946 | return NULL; | |
947 | } | |
31f7ba04 | 948 | |
2593f09a NC |
949 | dir = strdup (abfd->filename); |
950 | if (dir == NULL) | |
951 | { | |
952 | free (basename); | |
953 | return NULL; | |
954 | } | |
31f7ba04 NC |
955 | BFD_ASSERT (strlen (dir) != 0); |
956 | ||
957 | /* Strip off filename part. */ | |
958 | for (i = strlen (dir) - 1; i >= 0; i--) | |
959 | if (IS_DIR_SEPARATOR (dir[i])) | |
960 | break; | |
961 | ||
962 | dir[i + 1] = '\0'; | |
963 | BFD_ASSERT (dir[i] == '/' || dir[0] == '\0') | |
964 | ||
2593f09a NC |
965 | debugfile = malloc (strlen (debug_file_directory) + 1 |
966 | + strlen (dir) | |
967 | + strlen (".debug/") | |
968 | + strlen (basename) | |
969 | + 1); | |
970 | if (debugfile == NULL) | |
971 | { | |
972 | free (basename); | |
973 | free (dir); | |
974 | return NULL; | |
975 | } | |
31f7ba04 NC |
976 | |
977 | /* First try in the same directory as the original file: */ | |
978 | strcpy (debugfile, dir); | |
979 | strcat (debugfile, basename); | |
980 | ||
981 | if (separate_debug_file_exists (debugfile, crc32)) | |
982 | { | |
983 | free (basename); | |
984 | free (dir); | |
985 | return debugfile; | |
986 | } | |
987 | ||
988 | /* Then try in a subdirectory called .debug. */ | |
989 | strcpy (debugfile, dir); | |
990 | strcat (debugfile, ".debug/"); | |
991 | strcat (debugfile, basename); | |
992 | ||
993 | if (separate_debug_file_exists (debugfile, crc32)) | |
994 | { | |
995 | free (basename); | |
996 | free (dir); | |
997 | return debugfile; | |
998 | } | |
999 | ||
1000 | /* Then try in the global debugfile directory. */ | |
1001 | strcpy (debugfile, debug_file_directory); | |
1002 | i = strlen (debug_file_directory) - 1; | |
1003 | if (i > 0 | |
1004 | && debug_file_directory[i] != '/' | |
1005 | && dir[0] != '/') | |
1006 | strcat (debugfile, "/"); | |
1007 | strcat (debugfile, dir); | |
1008 | strcat (debugfile, basename); | |
1009 | ||
1010 | if (separate_debug_file_exists (debugfile, crc32)) | |
1011 | { | |
1012 | free (basename); | |
1013 | free (dir); | |
1014 | return debugfile; | |
1015 | } | |
1016 | ||
1017 | free (debugfile); | |
1018 | free (basename); | |
1019 | free (dir); | |
1020 | return NULL; | |
1021 | } | |
1022 | ||
1023 | ||
1024 | /* | |
1025 | FUNCTION | |
1026 | bfd_follow_gnu_debuglink | |
1027 | ||
1028 | SYNOPSIS | |
1029 | char * bfd_follow_gnu_debuglink(bfd *abfd, const char *dir); | |
1030 | ||
1031 | DESCRIPTION | |
1032 | ||
1033 | Takes a BFD and searches it for a .gnu_debuglink section. If this | |
1034 | section is found, examines the section for the name and checksum of | |
1035 | a '.debug' file containing auxiliary debugging | |
1036 | information. Searches filesystem for .debug file in some standard | |
1037 | locations, including the directory tree rooted at @var{dir}, and if | |
1038 | found returns the full filename. If @var{dir} is NULL, will search | |
1039 | default path configured into libbfd at build time. | |
1040 | ||
1041 | RETURNS | |
1042 | <<NULL>> on any errors or failure to locate the .debug file, | |
1043 | otherwise a pointer to a heap-allocated string containing the | |
1044 | filename. The caller is responsible for freeing this string. | |
1045 | */ | |
1046 | ||
1047 | char * | |
1048 | bfd_follow_gnu_debuglink (abfd, dir) | |
1049 | bfd *abfd; | |
1050 | const char * dir; | |
1051 | { | |
1052 | #if 0 /* Disabled until DEBUGDIR can be defined by configure.in */ | |
1053 | if (dir == NULL) | |
1054 | dir = DEBUGDIR; | |
1055 | #endif | |
1056 | return find_separate_debug_file (abfd, dir); | |
1057 | } | |
2593f09a NC |
1058 | |
1059 | /* | |
1060 | FUNCTION | |
1061 | bfd_add_gnu_debuglink | |
1062 | ||
1063 | SYNOPSIS | |
1064 | bfd_boolean bfd_add_gnu_debuglink (bfd * abfd, const char * filename); | |
1065 | ||
1066 | DESCRIPTION | |
1067 | ||
1068 | Takes a @var{BFD} and adds a .gnu_debuglink section containing a link | |
1069 | to the specified @var{filename}. The filename should be relative to | |
1070 | the current directory. | |
1071 | ||
1072 | RETURNS | |
1073 | <<TRUE>> is returned if all is ok. Otherwise <<FALSE>> is returned | |
1074 | and bfd_error is set. | |
1075 | */ | |
1076 | ||
1077 | bfd_boolean | |
1078 | bfd_add_gnu_debuglink (abfd, filename) | |
1079 | bfd *abfd; | |
1080 | const char * filename; | |
1081 | { | |
1082 | asection * sect; | |
1083 | bfd_size_type debuglink_size; | |
1084 | unsigned long crc32; | |
1085 | char * contents; | |
1086 | bfd_size_type crc_offset; | |
1087 | FILE * handle; | |
1088 | static char buffer[8 * 1024]; | |
1089 | size_t count; | |
1090 | ||
1091 | if (abfd == NULL || filename == NULL) | |
1092 | { | |
1093 | bfd_set_error (bfd_error_invalid_operation); | |
1094 | return FALSE; | |
1095 | } | |
1096 | ||
1097 | /* Make sure that we can read the file. | |
1098 | XXX - Should we attempt to locate the debug info file using the same | |
1099 | algorithm as gdb ? At the moment, since we are creating the | |
1100 | .gnu_debuglink section, we insist upon the user providing us with a | |
1101 | correct-for-section-creation-time path, but this need not conform to | |
1102 | the gdb location algorithm. */ | |
1103 | handle = fopen (filename, FOPEN_RB); | |
1104 | if (handle == NULL) | |
1105 | { | |
1106 | bfd_set_error (bfd_error_system_call); | |
1107 | return FALSE; | |
1108 | } | |
1109 | ||
1110 | crc32 = 0; | |
1111 | while ((count = fread (buffer, 1, sizeof buffer, handle)) > 0) | |
1112 | crc32 = bfd_calc_gnu_debuglink_crc32 (crc32, buffer, count); | |
1113 | fclose (handle); | |
1114 | ||
1115 | /* Strip off any path components in filename, | |
1116 | now that we no longer need them. */ | |
1117 | filename = lbasename (filename); | |
1118 | ||
1119 | sect = bfd_get_section_by_name (abfd, GNU_DEBUGLINK); | |
1120 | if (sect) | |
1121 | { | |
1122 | /* Section already exists. */ | |
1123 | bfd_set_error (bfd_error_invalid_operation); | |
1124 | return FALSE; | |
1125 | } | |
1126 | ||
1127 | sect = bfd_make_section (abfd, GNU_DEBUGLINK); | |
1128 | if (sect == NULL) | |
1129 | return FALSE; | |
1130 | ||
1131 | if (! bfd_set_section_flags (abfd, sect, | |
1132 | SEC_HAS_CONTENTS | SEC_DEBUGGING)) | |
1133 | /* XXX Should we delete the section from the bfd ? */ | |
1134 | return FALSE; | |
1135 | ||
1136 | ||
1137 | debuglink_size = strlen (filename) + 1; | |
1138 | debuglink_size += 3; | |
1139 | debuglink_size &= ~3; | |
1140 | debuglink_size += 4; | |
1141 | ||
1142 | if (! bfd_set_section_size (abfd, sect, debuglink_size)) | |
1143 | /* XXX Should we delete the section from the bfd ? */ | |
1144 | return FALSE; | |
1145 | ||
1146 | contents = malloc (debuglink_size); | |
1147 | if (contents == NULL) | |
1148 | { | |
1149 | /* XXX Should we delete the section from the bfd ? */ | |
1150 | bfd_set_error (bfd_error_no_memory); | |
1151 | return FALSE; | |
1152 | } | |
1153 | ||
1154 | strcpy (contents, filename); | |
1155 | crc_offset = debuglink_size - 4; | |
1156 | ||
1157 | bfd_put_32 (abfd, crc32, (bfd_byte *) (contents + crc_offset)); | |
1158 | ||
1159 | if (! bfd_set_section_contents (abfd, sect, contents, | |
1160 | (file_ptr)0, debuglink_size)) | |
1161 | { | |
1162 | /* XXX Should we delete the section from the bfd ? */ | |
1163 | free (contents); | |
1164 | return FALSE; | |
1165 | } | |
1166 | ||
1167 | return TRUE; | |
1168 | } |