File: | src/gnu/usr.bin/binutils/bfd/archive64.c |
Warning: | line 156, column 8 Value stored to 'current' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* MIPS-specific support for 64-bit ELF |
2 | Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 |
3 | Free Software Foundation, Inc. |
4 | Ian Lance Taylor, Cygnus Support |
5 | Linker support added by Mark Mitchell, CodeSourcery, LLC. |
6 | <mark@codesourcery.com> |
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
23 | |
24 | /* This file supports the 64-bit (MIPS) ELF archives. */ |
25 | |
26 | #include "bfd.h" |
27 | #include "sysdep.h" |
28 | #include "libbfd.h" |
29 | #include "aout/ar.h" |
30 | |
31 | /* Irix 6 defines a 64bit archive map format, so that they can |
32 | have archives more than 4 GB in size. */ |
33 | |
34 | bfd_boolean bfd_elf64_archive_slurp_armap (bfd *); |
35 | bfd_boolean bfd_elf64_archive_write_armap |
36 | (bfd *, unsigned int, struct orl *, unsigned int, int); |
37 | |
38 | /* Read an Irix 6 armap. */ |
39 | |
40 | bfd_boolean |
41 | bfd_elf64_archive_slurp_armap (bfd *abfd) |
42 | { |
43 | struct artdata *ardata = bfd_ardata (abfd)((abfd)->tdata.aout_ar_data); |
44 | char nextname[17]; |
45 | file_ptr arhdrpos; |
46 | bfd_size_type i, parsed_size, nsymz, stringsize, carsym_size, ptrsize; |
47 | struct areltdata *mapdata; |
48 | bfd_byte int_buf[8]; |
49 | char *stringbase; |
50 | bfd_byte *raw_armap = NULL((void*)0); |
51 | carsym *carsyms; |
52 | bfd_size_type amt; |
53 | |
54 | ardata->symdefs = NULL((void*)0); |
55 | |
56 | /* Get the name of the first element. */ |
57 | arhdrpos = bfd_tell (abfd); |
58 | i = bfd_bread (nextname, 16, abfd); |
59 | if (i == 0) |
60 | return TRUE1; |
61 | if (i != 16) |
62 | return FALSE0; |
63 | |
64 | if (bfd_seek (abfd, (file_ptr) - 16, SEEK_CUR1) != 0) |
65 | return FALSE0; |
66 | |
67 | /* Archives with traditional armaps are still permitted. */ |
68 | if (strncmp (nextname, "/ ", 16) == 0) |
69 | return bfd_slurp_armap (abfd); |
70 | |
71 | if (strncmp (nextname, "/SYM64/ ", 16) != 0) |
72 | { |
73 | bfd_has_map (abfd)((abfd)->has_armap) = FALSE0; |
74 | return TRUE1; |
75 | } |
76 | |
77 | mapdata = (struct areltdata *) _bfd_read_ar_hdr (abfd)((*((abfd)->xvec->_bfd_read_ar_hdr_fn)) (abfd)); |
78 | if (mapdata == NULL((void*)0)) |
79 | return FALSE0; |
80 | parsed_size = mapdata->parsed_size; |
81 | bfd_release (abfd, mapdata); |
82 | |
83 | if (bfd_bread (int_buf, 8, abfd) != 8) |
84 | { |
85 | if (bfd_get_error () != bfd_error_system_call) |
86 | bfd_set_error (bfd_error_malformed_archive); |
87 | return FALSE0; |
88 | } |
89 | |
90 | nsymz = bfd_getb64 (int_buf); |
91 | stringsize = parsed_size - 8 * nsymz - 8; |
92 | |
93 | carsym_size = nsymz * sizeof (carsym); |
94 | ptrsize = 8 * nsymz; |
95 | |
96 | amt = carsym_size + stringsize + 1; |
97 | ardata->symdefs = bfd_zalloc (abfd, amt); |
98 | if (ardata->symdefs == NULL((void*)0)) |
99 | return FALSE0; |
100 | carsyms = ardata->symdefs; |
101 | stringbase = ((char *) ardata->symdefs) + carsym_size; |
102 | |
103 | raw_armap = bfd_alloc (abfd, ptrsize); |
104 | if (raw_armap == NULL((void*)0)) |
105 | goto release_symdefs; |
106 | |
107 | if (bfd_bread (raw_armap, ptrsize, abfd) != ptrsize |
108 | || bfd_bread (stringbase, stringsize, abfd) != stringsize) |
109 | { |
110 | if (bfd_get_error () != bfd_error_system_call) |
111 | bfd_set_error (bfd_error_malformed_archive); |
112 | goto release_raw_armap; |
113 | } |
114 | |
115 | for (i = 0; i < nsymz; i++) |
116 | { |
117 | carsyms->file_offset = bfd_getb64 (raw_armap + i * 8); |
118 | carsyms->name = stringbase; |
119 | stringbase += strlen (stringbase) + 1; |
120 | ++carsyms; |
121 | } |
122 | *stringbase = '\0'; |
123 | |
124 | ardata->symdef_count = nsymz; |
125 | ardata->first_file_filepos = bfd_tell (abfd); |
126 | /* Pad to an even boundary if you have to. */ |
127 | ardata->first_file_filepos += (ardata->first_file_filepos) % 2; |
128 | |
129 | bfd_has_map (abfd)((abfd)->has_armap) = TRUE1; |
130 | bfd_release (abfd, raw_armap); |
131 | |
132 | return TRUE1; |
133 | |
134 | release_raw_armap: |
135 | bfd_release (abfd, raw_armap); |
136 | release_symdefs: |
137 | bfd_release (abfd, ardata->symdefs); |
138 | return FALSE0; |
139 | } |
140 | |
141 | /* Write out an Irix 6 armap. The Irix 6 tools are supposed to be |
142 | able to handle ordinary ELF armaps, but at least on Irix 6.2 the |
143 | linker crashes. */ |
144 | |
145 | bfd_boolean |
146 | bfd_elf64_archive_write_armap (bfd *arch, |
147 | unsigned int elength, |
148 | struct orl *map, |
149 | unsigned int symbol_count, |
150 | int stridx) |
151 | { |
152 | unsigned int ranlibsize = (symbol_count * 8) + 8; |
153 | unsigned int stringsize = stridx; |
154 | unsigned int mapsize = stringsize + ranlibsize; |
155 | file_ptr archive_member_file_ptr; |
156 | bfd *current = arch->archive_head; |
Value stored to 'current' during its initialization is never read | |
157 | unsigned int count; |
158 | struct ar_hdr hdr; |
159 | unsigned int i; |
160 | int padding; |
161 | bfd_byte buf[8]; |
162 | |
163 | padding = BFD_ALIGN (mapsize, 8)((((bfd_vma) (mapsize) + (8) - 1) >= (bfd_vma) (mapsize)) ? (((bfd_vma) (mapsize) + ((8) - 1)) & ~ (bfd_vma) ((8)-1) ) : ~ (bfd_vma) 0) - mapsize; |
164 | mapsize += padding; |
165 | |
166 | /* work out where the first object file will go in the archive */ |
167 | archive_member_file_ptr = (mapsize |
168 | + elength |
169 | + sizeof (struct ar_hdr) |
170 | + SARMAG8); |
171 | |
172 | memset (&hdr, 0, sizeof (struct ar_hdr)); |
173 | strcpy (hdr.ar_name, "/SYM64/"); |
174 | sprintf (hdr.ar_size, "%-10d", (int) mapsize); |
175 | sprintf (hdr.ar_date, "%ld", (long) time (NULL((void*)0))); |
176 | /* This, at least, is what Intel coff sets the values to.: */ |
177 | sprintf ((hdr.ar_uid), "%d", 0); |
178 | sprintf ((hdr.ar_gid), "%d", 0); |
179 | sprintf ((hdr.ar_mode), "%-7o", (unsigned) 0); |
180 | strncpy (hdr.ar_fmag, ARFMAG"`\012", 2); |
181 | |
182 | for (i = 0; i < sizeof (struct ar_hdr); i++) |
183 | if (((char *) (&hdr))[i] == '\0') |
184 | (((char *) (&hdr))[i]) = ' '; |
185 | |
186 | /* Write the ar header for this item and the number of symbols */ |
187 | |
188 | if (bfd_bwrite (&hdr, sizeof (struct ar_hdr), arch) |
189 | != sizeof (struct ar_hdr)) |
190 | return FALSE0; |
191 | |
192 | bfd_putb64 ((bfd_vma) symbol_count, buf); |
193 | if (bfd_bwrite (buf, 8, arch) != 8) |
194 | return FALSE0; |
195 | |
196 | /* Two passes, first write the file offsets for each symbol - |
197 | remembering that each offset is on a two byte boundary. */ |
198 | |
199 | /* Write out the file offset for the file associated with each |
200 | symbol, and remember to keep the offsets padded out. */ |
201 | |
202 | current = arch->archive_head; |
203 | count = 0; |
204 | while (current != NULL((void*)0) && count < symbol_count) |
205 | { |
206 | /* For each symbol which is used defined in this object, write out |
207 | the object file's address in the archive */ |
208 | |
209 | while (map[count].u.abfd == current) |
210 | { |
211 | bfd_putb64 ((bfd_vma) archive_member_file_ptr, buf); |
212 | if (bfd_bwrite (buf, 8, arch) != 8) |
213 | return FALSE0; |
214 | count++; |
215 | } |
216 | /* Add size of this archive entry */ |
217 | archive_member_file_ptr += (arelt_size (current)(((struct areltdata *)((current)->arelt_data))->parsed_size ) |
218 | + sizeof (struct ar_hdr)); |
219 | /* remember about the even alignment */ |
220 | archive_member_file_ptr += archive_member_file_ptr % 2; |
221 | current = current->next; |
222 | } |
223 | |
224 | /* now write the strings themselves */ |
225 | for (count = 0; count < symbol_count; count++) |
226 | { |
227 | size_t len = strlen (*map[count].name) + 1; |
228 | |
229 | if (bfd_bwrite (*map[count].name, len, arch) != len) |
230 | return FALSE0; |
231 | } |
232 | |
233 | /* The spec says that this should be padded to an 8 byte boundary. |
234 | However, the Irix 6.2 tools do not appear to do this. */ |
235 | while (padding != 0) |
236 | { |
237 | if (bfd_bwrite ("", 1, arch) != 1) |
238 | return FALSE0; |
239 | --padding; |
240 | } |
241 | |
242 | return TRUE1; |
243 | } |