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