daily update
[binutils.git] / libiberty / simple-object.c
blobd000cfc08067e89dce043bc35de9b2726644cb3a
1 /* simple-object.c -- simple routines to read and write object files.
2 Copyright 2010 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Google.
5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 2, or (at your option) any
8 later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, 51 Franklin Street - Fifth Floor,
18 Boston, MA 02110-1301, USA. */
20 #include "config.h"
21 #include "libiberty.h"
22 #include "simple-object.h"
24 #include <errno.h>
26 #ifdef HAVE_STDLIB_H
27 #include <stdlib.h>
28 #endif
30 #ifdef HAVE_STDINT_H
31 #include <stdint.h>
32 #endif
34 #ifdef HAVE_STRING_H
35 #include <string.h>
36 #endif
38 #ifdef HAVE_INTTYPES_H
39 #include <inttypes.h>
40 #endif
42 #ifndef SEEK_SET
43 #define SEEK_SET 0
44 #endif
46 #include "simple-object-common.h"
48 /* The known object file formats. */
50 static const struct simple_object_functions * const format_functions[] =
52 &simple_object_elf_functions,
53 &simple_object_mach_o_functions,
54 &simple_object_coff_functions
57 /* Read data from a file using the simple_object error reporting
58 conventions. */
60 int
61 simple_object_internal_read (int descriptor, off_t offset,
62 unsigned char *buffer, size_t size,
63 const char **errmsg, int *err)
65 ssize_t got;
67 if (lseek (descriptor, offset, SEEK_SET) < 0)
69 *errmsg = "lseek";
70 *err = errno;
71 return 0;
74 got = read (descriptor, buffer, size);
75 if (got < 0)
77 *errmsg = "read";
78 *err = errno;
79 return 0;
82 if ((size_t) got < size)
84 *errmsg = "file too short";
85 *err = 0;
86 return 0;
89 return 1;
92 /* Write data to a file using the simple_object error reporting
93 conventions. */
95 int
96 simple_object_internal_write (int descriptor, off_t offset,
97 const unsigned char *buffer, size_t size,
98 const char **errmsg, int *err)
100 ssize_t wrote;
102 if (lseek (descriptor, offset, SEEK_SET) < 0)
104 *errmsg = "lseek";
105 *err = errno;
106 return 0;
109 wrote = write (descriptor, buffer, size);
110 if (wrote < 0)
112 *errmsg = "write";
113 *err = errno;
114 return 0;
117 if ((size_t) wrote < size)
119 *errmsg = "short write";
120 *err = 0;
121 return 0;
124 return 1;
127 /* Open for read. */
129 simple_object_read *
130 simple_object_start_read (int descriptor, off_t offset,
131 const char *segment_name, const char **errmsg,
132 int *err)
134 unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN];
135 size_t len, i;
137 if (!simple_object_internal_read (descriptor, offset, header,
138 SIMPLE_OBJECT_MATCH_HEADER_LEN,
139 errmsg, err))
140 return NULL;
142 len = sizeof (format_functions) / sizeof (format_functions[0]);
143 for (i = 0; i < len; ++i)
145 void *data;
147 data = format_functions[i]->match (header, descriptor, offset,
148 segment_name, errmsg, err);
149 if (data != NULL)
151 simple_object_read *ret;
153 ret = XNEW (simple_object_read);
154 ret->descriptor = descriptor;
155 ret->offset = offset;
156 ret->functions = format_functions[i];
157 ret->data = data;
158 return ret;
162 *errmsg = "file not recognized";
163 *err = 0;
164 return NULL;
167 /* Find all sections. */
169 const char *
170 simple_object_find_sections (simple_object_read *sobj,
171 int (*pfn) (void *, const char *, off_t, off_t),
172 void *data,
173 int *err)
175 return sobj->functions->find_sections (sobj, pfn, data, err);
178 /* Internal data passed to find_one_section. */
180 struct find_one_section_data
182 /* The section we are looking for. */
183 const char *name;
184 /* Where to store the section offset. */
185 off_t *offset;
186 /* Where to store the section length. */
187 off_t *length;
188 /* Set if the name is found. */
189 int found;
192 /* Internal function passed to find_sections. */
194 static int
195 find_one_section (void *data, const char *name, off_t offset, off_t length)
197 struct find_one_section_data *fosd = (struct find_one_section_data *) data;
199 if (strcmp (name, fosd->name) != 0)
200 return 1;
202 *fosd->offset = offset;
203 *fosd->length = length;
204 fosd->found = 1;
206 /* Stop iteration. */
207 return 0;
210 /* Find a section. */
213 simple_object_find_section (simple_object_read *sobj, const char *name,
214 off_t *offset, off_t *length,
215 const char **errmsg, int *err)
217 struct find_one_section_data fosd;
219 fosd.name = name;
220 fosd.offset = offset;
221 fosd.length = length;
222 fosd.found = 0;
224 *errmsg = simple_object_find_sections (sobj, find_one_section,
225 (void *) &fosd, err);
226 if (*errmsg != NULL)
227 return 0;
228 if (!fosd.found)
229 return 0;
230 return 1;
233 /* Fetch attributes. */
235 simple_object_attributes *
236 simple_object_fetch_attributes (simple_object_read *sobj, const char **errmsg,
237 int *err)
239 void *data;
240 simple_object_attributes *ret;
242 data = sobj->functions->fetch_attributes (sobj, errmsg, err);
243 if (data == NULL)
244 return NULL;
245 ret = XNEW (simple_object_attributes);
246 ret->functions = sobj->functions;
247 ret->data = data;
248 return ret;
251 /* Release an simple_object_read. */
253 void
254 simple_object_release_read (simple_object_read *sobj)
256 sobj->functions->release_read (sobj->data);
257 XDELETE (sobj);
260 /* Merge attributes. */
262 const char *
263 simple_object_attributes_merge (simple_object_attributes *to,
264 simple_object_attributes *from,
265 int *err)
267 if (to->functions != from->functions)
269 *err = 0;
270 return "different object file format";
272 return to->functions->attributes_merge (to->data, from->data, err);
275 /* Release an attributes structure. */
277 void
278 simple_object_release_attributes (simple_object_attributes *attrs)
280 attrs->functions->release_attributes (attrs->data);
281 XDELETE (attrs);
284 /* Start creating an object file. */
286 simple_object_write *
287 simple_object_start_write (simple_object_attributes *attrs,
288 const char *segment_name, const char **errmsg,
289 int *err)
291 void *data;
292 simple_object_write *ret;
294 data = attrs->functions->start_write (attrs->data, errmsg, err);
295 if (data == NULL)
296 return NULL;
297 ret = XNEW (simple_object_write);
298 ret->functions = attrs->functions;
299 ret->segment_name = xstrdup (segment_name);
300 ret->sections = NULL;
301 ret->last_section = NULL;
302 ret->data = data;
303 return ret;
306 /* Start creating a section. */
308 simple_object_write_section *
309 simple_object_write_create_section (simple_object_write *sobj, const char *name,
310 unsigned int align,
311 const char **errmsg ATTRIBUTE_UNUSED,
312 int *err ATTRIBUTE_UNUSED)
314 simple_object_write_section *ret;
316 ret = XNEW (simple_object_write_section);
317 ret->next = NULL;
318 ret->name = xstrdup (name);
319 ret->align = align;
320 ret->buffers = NULL;
321 ret->last_buffer = NULL;
323 if (sobj->last_section == NULL)
325 sobj->sections = ret;
326 sobj->last_section = ret;
328 else
330 sobj->last_section->next = ret;
331 sobj->last_section = ret;
334 return ret;
337 /* Add data to a section. */
339 const char *
340 simple_object_write_add_data (simple_object_write *sobj ATTRIBUTE_UNUSED,
341 simple_object_write_section *section,
342 const void *buffer,
343 size_t size, int copy,
344 int *err ATTRIBUTE_UNUSED)
346 struct simple_object_write_section_buffer *wsb;
348 wsb = XNEW (struct simple_object_write_section_buffer);
349 wsb->next = NULL;
350 wsb->size = size;
352 if (!copy)
354 wsb->buffer = buffer;
355 wsb->free_buffer = NULL;
357 else
359 wsb->free_buffer = (void *) XNEWVEC (char, size);
360 memcpy (wsb->free_buffer, buffer, size);
361 wsb->buffer = wsb->free_buffer;
364 if (section->last_buffer == NULL)
366 section->buffers = wsb;
367 section->last_buffer = wsb;
369 else
371 section->last_buffer->next = wsb;
372 section->last_buffer = wsb;
375 return NULL;
378 /* Write the complete object file. */
380 const char *
381 simple_object_write_to_file (simple_object_write *sobj, int descriptor,
382 int *err)
384 return sobj->functions->write_to_file (sobj, descriptor, err);
387 /* Release an simple_object_write. */
389 void
390 simple_object_release_write (simple_object_write *sobj)
392 simple_object_write_section *section;
394 free (sobj->segment_name);
396 section = sobj->sections;
397 while (section != NULL)
399 struct simple_object_write_section_buffer *buffer;
400 simple_object_write_section *next_section;
402 buffer = section->buffers;
403 while (buffer != NULL)
405 struct simple_object_write_section_buffer *next_buffer;
407 if (buffer->free_buffer != NULL)
408 XDELETEVEC (buffer->free_buffer);
409 next_buffer = buffer->next;
410 XDELETE (buffer);
411 buffer = next_buffer;
414 next_section = section->next;
415 free (section->name);
416 XDELETE (section);
417 section = next_section;
420 sobj->functions->release_write (sobj->data);
421 XDELETE (sobj);