OSDN Git Service

include/:
[pf3gnuchains/gcc-fork.git] / libiberty / simple-object-common.h
1 /* simple-object-common.h -- common structs for object file manipulation.
2    Copyright (C) 2010 Free Software Foundation, Inc.
3
4 This file is part of the libiberty library.
5 Libiberty is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 Libiberty 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 GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with libiberty; see the file COPYING.LIB.  If not,
17 write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
18 Boston, MA 02110-1301, USA.  */
19
20 /* Forward reference.  */
21 struct simple_object_functions;
22
23 /* An object file opened for reading.  */
24
25 struct simple_object_read_struct
26 {
27   /* The file descriptor.  */
28   int descriptor;
29   /* The offset within the file.  */
30   off_t offset;
31   /* The functions which do the actual work.  */
32   const struct simple_object_functions *functions;
33   /* Private data for the object file format.  */
34   void *data;
35 };
36
37 /* Object file attributes.  */
38
39 struct simple_object_attributes_struct
40 {
41   /* The functions which do the actual work.  */
42   const struct simple_object_functions *functions;
43   /* Private data for the object file format.  */
44   void *data;
45 };
46
47 /* An object file being created.  */
48
49 struct simple_object_write_struct
50 {
51   /* The functions which do the actual work.  */
52   const struct simple_object_functions *functions;
53   /* The segment_name argument from the user.  */
54   char *segment_name;
55   /* The start of the list of sections.  */
56   simple_object_write_section *sections;
57   /* The last entry in the list of sections.  */
58   simple_object_write_section *last_section;
59   /* Private data for the object file format.  */
60   void *data;
61 };
62
63 /* A section in an object file being created.  */
64
65 struct simple_object_write_section_struct
66 {
67   /* Next in the list of sections attached to an
68      simple_object_write.  */
69   simple_object_write_section *next;
70   /* The name of this section.  */
71   char *name;
72   /* The required alignment.  */
73   unsigned int align;
74   /* The first data attached to this section.  */
75   struct simple_object_write_section_buffer *buffers;
76   /* The last data attached to this section.  */
77   struct simple_object_write_section_buffer *last_buffer;
78 };
79
80 /* Data attached to a section.  */
81
82 struct simple_object_write_section_buffer
83 {
84   /* The next data for this section.  */
85   struct simple_object_write_section_buffer *next;
86   /* The size of the buffer.  */
87   size_t size;
88   /* The actual bytes.  */
89   const void *buffer;
90   /* A buffer to free, or NULL.  */
91   void *free_buffer;
92 };
93
94 /* The number of bytes we read from the start of the file to pass to
95    the match function.  */
96 #define SIMPLE_OBJECT_MATCH_HEADER_LEN (16)
97
98 /* Format-specific object file functions.  */
99
100 struct simple_object_functions
101 {
102   /* If this file matches these functions, return a new value for the
103      private data for an simple_object_read.  HEADER is the first 16
104      bytes of the file.  DESCRIPTOR, OFFSET, SEGMENT_NAME, ERRMSG, and
105      ERR are as for simple_object_open_read.  If this file does not
106      match, this function should return NULL with *ERRMSG set to
107      NULL.  */
108   void *(*match) (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
109                   int descriptor, off_t offset, const char *segment_name,
110                   const char **errmsg, int *err);
111
112   /* Implement simple_object_find_sections.  */
113   const char *(*find_sections) (simple_object_read *,
114                                 int (*pfn) (void *, const char *,
115                                             off_t offset, off_t length),
116                                 void *data,
117                                 int *err);
118
119   /* Return the private data for the attributes for SOBJ.  */
120   void *(*fetch_attributes) (simple_object_read *sobj, const char **errmsg,
121                              int *err);
122
123   /* Release the private data for an simple_object_read.  */
124   void (*release_read) (void *);
125
126   /* Compare the private data for the attributes of two files.  If
127      they are the same, in the sense that they could be linked
128      together, return NULL.  Otherwise return an error message.  */
129   const char *(*attributes_compare) (void *, void *, int *err);
130
131   /* Release the private data for an simple_object_attributes.  */
132   void (*release_attributes) (void *);
133
134   /* Start creating an object file.  */
135   void *(*start_write) (void *attributes_data, const char **errmsg,
136                         int *err);
137
138   /* Write the complete object file.  */
139   const char *(*write_to_file) (simple_object_write *sobj, int descriptor,
140                                 int *err);
141
142   /* Release the private data for an simple_object_write.  */
143   void (*release_write) (void *);
144 };
145
146 /* The known object file formats.  */
147
148 extern const struct simple_object_functions simple_object_coff_functions;
149 extern const struct simple_object_functions simple_object_elf_functions;
150 extern const struct simple_object_functions simple_object_mach_o_functions;
151
152 /* Read SIZE bytes from DESCRIPTOR at file offset OFFSET into BUFFER.
153    Return non-zero on success.  On failure return 0 and set *ERRMSG
154    and *ERR.  */
155
156 extern int
157 simple_object_internal_read (int descriptor, off_t offset,
158                              unsigned char *buffer, size_t size,
159                              const char **errmsg, int *err);
160
161 /* Write SIZE bytes from BUFFER to DESCRIPTOR at file offset OFFSET.
162    Return non-zero on success.  On failure return 0 and set *ERRMSG
163    and *ERR.  */
164
165 extern int
166 simple_object_internal_write (int descriptor, off_t offset,
167                               const unsigned char *buffer, size_t size,
168                               const char **errmsg, int *err);
169
170 /* Define ulong_type as an unsigned 64-bit type if available.
171    Otherwise just make it unsigned long.  */
172
173 #ifdef UNSIGNED_64BIT_TYPE
174 __extension__ typedef UNSIGNED_64BIT_TYPE ulong_type;
175 #else
176 typedef unsigned long ulong_type;
177 #endif
178
179 /* Fetch a big-endian 16-bit value.  */
180
181 static inline unsigned short
182 simple_object_fetch_big_16 (const unsigned char *buf)
183 {
184   return ((unsigned short) buf[0] << 8) | (unsigned short) buf[1];
185 }
186
187 /* Fetch a little-endian 16-bit value.  */
188
189 static inline unsigned short
190 simple_object_fetch_little_16 (const unsigned char *buf)
191 {
192   return ((unsigned short) buf[1] << 8) | (unsigned short) buf[0];
193 }
194
195 /* Fetch a big-endian 32-bit value.  */
196
197 static inline unsigned int
198 simple_object_fetch_big_32 (const unsigned char *buf)
199 {
200   return (((unsigned int) buf[0] << 24)
201           | ((unsigned int) buf[1] << 16)
202           | ((unsigned int) buf[2] << 8)
203           | (unsigned int) buf[3]);
204 }
205
206 /* Fetch a little-endian 32-bit value.  */
207
208 static inline unsigned int
209 simple_object_fetch_little_32 (const unsigned char *buf)
210 {
211   return (((unsigned int) buf[3] << 24)
212           | ((unsigned int) buf[2] << 16)
213           | ((unsigned int) buf[1] << 8)
214           | (unsigned int) buf[0]);
215 }
216
217 /* Fetch a big-endian 32-bit value as a ulong_type.  */
218
219 static inline ulong_type
220 simple_object_fetch_big_32_ulong (const unsigned char *buf)
221 {
222   return (ulong_type) simple_object_fetch_big_32 (buf);
223 }
224
225 /* Fetch a little-endian 32-bit value as a ulong_type.  */
226
227 static inline ulong_type
228 simple_object_fetch_little_32_ulong (const unsigned char *buf)
229 {
230   return (ulong_type) simple_object_fetch_little_32 (buf);
231 }
232
233 #ifdef UNSIGNED_64BIT_TYPE
234
235 /* Fetch a big-endian 64-bit value.  */
236
237 static inline ulong_type
238 simple_object_fetch_big_64 (const unsigned char *buf)
239 {
240   return (((ulong_type) buf[0] << 56)
241           | ((ulong_type) buf[1] << 48)
242           | ((ulong_type) buf[2] << 40)
243           | ((ulong_type) buf[3] << 32)
244           | ((ulong_type) buf[4] << 24)
245           | ((ulong_type) buf[5] << 16)
246           | ((ulong_type) buf[6] << 8)
247           | (ulong_type) buf[7]);
248 }
249
250 /* Fetch a little-endian 64-bit value.  */
251
252 static inline ulong_type
253 simple_object_fetch_little_64 (const unsigned char *buf)
254 {
255   return (((ulong_type) buf[7] << 56)
256           | ((ulong_type) buf[6] << 48)
257           | ((ulong_type) buf[5] << 40)
258           | ((ulong_type) buf[4] << 32)
259           | ((ulong_type) buf[3] << 24)
260           | ((ulong_type) buf[2] << 16)
261           | ((ulong_type) buf[1] << 8)
262           | (ulong_type) buf[0]);
263 }
264
265 #endif
266
267 /* Store a big-endian 16-bit value.  */
268
269 static inline void
270 simple_object_set_big_16 (unsigned char *buf, unsigned short val)
271 {
272   buf[0] = (val >> 8) & 0xff;
273   buf[1] = val & 0xff;
274 }
275
276 /* Store a little-endian 16-bit value.  */
277
278 static inline void
279 simple_object_set_little_16 (unsigned char *buf, unsigned short val)
280 {
281   buf[1] = (val >> 8) & 0xff;
282   buf[0] = val & 0xff;
283 }
284
285 /* Store a big-endian 32-bit value.  */
286
287 static inline void
288 simple_object_set_big_32 (unsigned char *buf, unsigned int val)
289 {
290   buf[0] = (val >> 24) & 0xff;
291   buf[1] = (val >> 16) & 0xff;
292   buf[2] = (val >> 8) & 0xff;
293   buf[3] = val & 0xff;
294 }
295
296 /* Store a little-endian 32-bit value.  */
297
298 static inline void
299 simple_object_set_little_32 (unsigned char *buf, unsigned int val)
300 {
301   buf[3] = (val >> 24) & 0xff;
302   buf[2] = (val >> 16) & 0xff;
303   buf[1] = (val >> 8) & 0xff;
304   buf[0] = val & 0xff;
305 }
306
307 /* Store a big-endian 32-bit value coming in as a ulong_type.  */
308
309 static inline void
310 simple_object_set_big_32_ulong (unsigned char *buf, ulong_type val)
311 {
312   simple_object_set_big_32 (buf, val);
313 }
314
315 /* Store a little-endian 32-bit value coming in as a ulong_type.  */
316
317 static inline void
318 simple_object_set_little_32_ulong (unsigned char *buf, ulong_type val)
319 {
320   simple_object_set_little_32 (buf, val);
321 }
322
323 #ifdef UNSIGNED_64BIT_TYPE
324
325 /* Store a big-endian 64-bit value.  */
326
327 static inline void
328 simple_object_set_big_64 (unsigned char *buf, ulong_type val)
329 {
330   buf[0] = (val >> 56) & 0xff;
331   buf[1] = (val >> 48) & 0xff;
332   buf[2] = (val >> 40) & 0xff;
333   buf[3] = (val >> 32) & 0xff;
334   buf[4] = (val >> 24) & 0xff;
335   buf[5] = (val >> 16) & 0xff;
336   buf[6] = (val >> 8) & 0xff;
337   buf[7] = val & 0xff;
338 }
339
340 /* Store a little-endian 64-bit value.  */
341
342 static inline void
343 simple_object_set_little_64 (unsigned char *buf, ulong_type val)
344 {
345   buf[7] = (val >> 56) & 0xff;
346   buf[6] = (val >> 48) & 0xff;
347   buf[5] = (val >> 40) & 0xff;
348   buf[4] = (val >> 32) & 0xff;
349   buf[3] = (val >> 24) & 0xff;
350   buf[2] = (val >> 16) & 0xff;
351   buf[1] = (val >> 8) & 0xff;
352   buf[0] = val & 0xff;
353 }
354
355 #endif