[binutils.git] / libiberty / simple-object-common.h

/* simple-object-common.h -- common structs for object file manipulation.
   Copyright (C) 2010 Free Software Foundation, Inc.

This file is part of the libiberty library.
Libiberty is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.

Libiberty is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Library General Public License for more details.

You should have received a copy of the GNU Library General Public
License along with libiberty; see the file COPYING.LIB.  If not,
write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
Boston, MA 02110-1301, USA.  */

/* Forward reference.  */
struct simple_object_functions;

/* An object file opened for reading.  */

struct simple_object_read_struct
{
  /* The file descriptor.  */
  int descriptor;
  /* The offset within the file.  */
  off_t offset;
  /* The functions which do the actual work.  */
  const struct simple_object_functions *functions;
  /* Private data for the object file format.  */
  void *data;
};

/* Object file attributes.  */

struct simple_object_attributes_struct
{
  /* The functions which do the actual work.  */
  const struct simple_object_functions *functions;
  /* Private data for the object file format.  */
  void *data;
};

/* An object file being created.  */

struct simple_object_write_struct
{
  /* The functions which do the actual work.  */
  const struct simple_object_functions *functions;
  /* The segment_name argument from the user.  */
  char *segment_name;
  /* The start of the list of sections.  */
  simple_object_write_section *sections;
  /* The last entry in the list of sections.  */
  simple_object_write_section *last_section;
  /* Private data for the object file format.  */
  void *data;
};

/* A section in an object file being created.  */

struct simple_object_write_section_struct
{
  /* Next in the list of sections attached to an
     simple_object_write.  */
  simple_object_write_section *next;
  /* The name of this section.  */
  char *name;
  /* The required alignment.  */
  unsigned int align;
  /* The first data attached to this section.  */
  struct simple_object_write_section_buffer *buffers;
  /* The last data attached to this section.  */
  struct simple_object_write_section_buffer *last_buffer;
};

/* Data attached to a section.  */

struct simple_object_write_section_buffer
{
  /* The next data for this section.  */
  struct simple_object_write_section_buffer *next;
  /* The size of the buffer.  */
  size_t size;
  /* The actual bytes.  */
  const void *buffer;
  /* A buffer to free, or NULL.  */
  void *free_buffer;
};

/* The number of bytes we read from the start of the file to pass to
   the match function.  */
#define SIMPLE_OBJECT_MATCH_HEADER_LEN (16)

/* Format-specific object file functions.  */

struct simple_object_functions
{
  /* If this file matches these functions, return a new value for the
     private data for an simple_object_read.  HEADER is the first 16
     bytes of the file.  DESCRIPTOR, OFFSET, SEGMENT_NAME, ERRMSG, and
     ERR are as for simple_object_open_read.  If this file does not
     match, this function should return NULL with *ERRMSG set to
     NULL.  */
  void *(*match) (unsigned char header[SIMPLE_OBJECT_MATCH_HEADER_LEN],
		  int descriptor, off_t offset, const char *segment_name,
		  const char **errmsg, int *err);

  /* Implement simple_object_find_sections.  */
  const char *(*find_sections) (simple_object_read *,
				int (*pfn) (void *, const char *,
					    off_t offset, off_t length),
				void *data,
				int *err);

  /* Return the private data for the attributes for SOBJ.  */
  void *(*fetch_attributes) (simple_object_read *sobj, const char **errmsg,
			     int *err);

  /* Release the private data for an simple_object_read.  */
  void (*release_read) (void *);

  /* Merge the private data for the attributes of two files.  If they
     could be linked together, return NULL.  Otherwise return an error
     message.  */
  const char *(*attributes_merge) (void *, void *, int *err);

  /* Release the private data for an simple_object_attributes.  */
  void (*release_attributes) (void *);

  /* Start creating an object file.  */
  void *(*start_write) (void *attributes_data, const char **errmsg,
			int *err);

  /* Write the complete object file.  */
  const char *(*write_to_file) (simple_object_write *sobj, int descriptor,
				int *err);

  /* Release the private data for an simple_object_write.  */
  void (*release_write) (void *);
};

/* The known object file formats.  */

extern const struct simple_object_functions simple_object_coff_functions;
extern const struct simple_object_functions simple_object_elf_functions;
extern const struct simple_object_functions simple_object_mach_o_functions;
extern const struct simple_object_functions simple_object_xcoff_functions;

/* Read SIZE bytes from DESCRIPTOR at file offset OFFSET into BUFFER.
   Return non-zero on success.  On failure return 0 and set *ERRMSG
   and *ERR.  */

extern int
simple_object_internal_read (int descriptor, off_t offset,
			     unsigned char *buffer, size_t size,
			     const char **errmsg, int *err);

/* Write SIZE bytes from BUFFER to DESCRIPTOR at file offset OFFSET.
   Return non-zero on success.  On failure return 0 and set *ERRMSG
   and *ERR.  */

extern int
simple_object_internal_write (int descriptor, off_t offset,
			      const unsigned char *buffer, size_t size,
			      const char **errmsg, int *err);

/* Define ulong_type as an unsigned 64-bit type if available.
   Otherwise just make it unsigned long.  */

#ifdef UNSIGNED_64BIT_TYPE
__extension__ typedef UNSIGNED_64BIT_TYPE ulong_type;
#else
typedef unsigned long ulong_type;
#endif

/* Fetch a big-endian 16-bit value.  */

static inline unsigned short
simple_object_fetch_big_16 (const unsigned char *buf)
{
  return ((unsigned short) buf[0] << 8) | (unsigned short) buf[1];
}

/* Fetch a little-endian 16-bit value.  */

static inline unsigned short
simple_object_fetch_little_16 (const unsigned char *buf)
{
  return ((unsigned short) buf[1] << 8) | (unsigned short) buf[0];
}

/* Fetch a big-endian 32-bit value.  */

static inline unsigned int
simple_object_fetch_big_32 (const unsigned char *buf)
{
  return (((unsigned int) buf[0] << 24)
	  | ((unsigned int) buf[1] << 16)
	  | ((unsigned int) buf[2] << 8)
	  | (unsigned int) buf[3]);
}

/* Fetch a little-endian 32-bit value.  */

static inline unsigned int
simple_object_fetch_little_32 (const unsigned char *buf)
{
  return (((unsigned int) buf[3] << 24)
	  | ((unsigned int) buf[2] << 16)
	  | ((unsigned int) buf[1] << 8)
	  | (unsigned int) buf[0]);
}

/* Fetch a big-endian 32-bit value as a ulong_type.  */

static inline ulong_type
simple_object_fetch_big_32_ulong (const unsigned char *buf)
{
  return (ulong_type) simple_object_fetch_big_32 (buf);
}

/* Fetch a little-endian 32-bit value as a ulong_type.  */

static inline ulong_type
simple_object_fetch_little_32_ulong (const unsigned char *buf)
{
  return (ulong_type) simple_object_fetch_little_32 (buf);
}

#ifdef UNSIGNED_64BIT_TYPE

/* Fetch a big-endian 64-bit value.  */

static inline ulong_type
simple_object_fetch_big_64 (const unsigned char *buf)
{
  return (((ulong_type) buf[0] << 56)
	  | ((ulong_type) buf[1] << 48)
	  | ((ulong_type) buf[2] << 40)
	  | ((ulong_type) buf[3] << 32)
	  | ((ulong_type) buf[4] << 24)
	  | ((ulong_type) buf[5] << 16)
	  | ((ulong_type) buf[6] << 8)
	  | (ulong_type) buf[7]);
}

/* Fetch a little-endian 64-bit value.  */

static inline ulong_type
simple_object_fetch_little_64 (const unsigned char *buf)
{
  return (((ulong_type) buf[7] << 56)
	  | ((ulong_type) buf[6] << 48)
	  | ((ulong_type) buf[5] << 40)
	  | ((ulong_type) buf[4] << 32)
	  | ((ulong_type) buf[3] << 24)
	  | ((ulong_type) buf[2] << 16)
	  | ((ulong_type) buf[1] << 8)
	  | (ulong_type) buf[0]);
}

#endif

/* Store a big-endian 16-bit value.  */

static inline void
simple_object_set_big_16 (unsigned char *buf, unsigned short val)
{
  buf[0] = (val >> 8) & 0xff;
  buf[1] = val & 0xff;
}

/* Store a little-endian 16-bit value.  */

static inline void
simple_object_set_little_16 (unsigned char *buf, unsigned short val)
{
  buf[1] = (val >> 8) & 0xff;
  buf[0] = val & 0xff;
}

/* Store a big-endian 32-bit value.  */

static inline void
simple_object_set_big_32 (unsigned char *buf, unsigned int val)
{
  buf[0] = (val >> 24) & 0xff;
  buf[1] = (val >> 16) & 0xff;
  buf[2] = (val >> 8) & 0xff;
  buf[3] = val & 0xff;
}

/* Store a little-endian 32-bit value.  */

static inline void
simple_object_set_little_32 (unsigned char *buf, unsigned int val)
{
  buf[3] = (val >> 24) & 0xff;
  buf[2] = (val >> 16) & 0xff;
  buf[1] = (val >> 8) & 0xff;
  buf[0] = val & 0xff;
}

/* Store a big-endian 32-bit value coming in as a ulong_type.  */

static inline void
simple_object_set_big_32_ulong (unsigned char *buf, ulong_type val)
{
  simple_object_set_big_32 (buf, val);
}

/* Store a little-endian 32-bit value coming in as a ulong_type.  */

static inline void
simple_object_set_little_32_ulong (unsigned char *buf, ulong_type val)
{
  simple_object_set_little_32 (buf, val);
}

#ifdef UNSIGNED_64BIT_TYPE

/* Store a big-endian 64-bit value.  */

static inline void
simple_object_set_big_64 (unsigned char *buf, ulong_type val)
{
  buf[0] = (val >> 56) & 0xff;
  buf[1] = (val >> 48) & 0xff;
  buf[2] = (val >> 40) & 0xff;
  buf[3] = (val >> 32) & 0xff;
  buf[4] = (val >> 24) & 0xff;
  buf[5] = (val >> 16) & 0xff;
  buf[6] = (val >> 8) & 0xff;
  buf[7] = val & 0xff;
}

/* Store a little-endian 64-bit value.  */

static inline void
simple_object_set_little_64 (unsigned char *buf, ulong_type val)
{
  buf[7] = (val >> 56) & 0xff;
  buf[6] = (val >> 48) & 0xff;
  buf[5] = (val >> 40) & 0xff;
  buf[4] = (val >> 32) & 0xff;
  buf[3] = (val >> 24) & 0xff;
  buf[2] = (val >> 16) & 0xff;
  buf[1] = (val >> 8) & 0xff;
  buf[0] = val & 0xff;
}

#endif
Commit	Line	Data
ffa54e5c DD	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
f9e6589d DD	126	/* Merge the private data for the attributes of two files. If they
	127	could be linked together, return NULL. Otherwise return an error
	128	message. */
	129	const char (attributes_merge) (void , void , int *err);
ffa54e5c DD	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;
07a8e9f0	151	extern const struct simple_object_functions simple_object_xcoff_functions;
ffa54e5c DD	152
	153	/* Read SIZE bytes from DESCRIPTOR at file offset OFFSET into BUFFER.
	154	Return non-zero on success. On failure return 0 and set *ERRMSG
	155	and ERR. /
	156
	157	extern int
	158	simple_object_internal_read (int descriptor, off_t offset,
	159	unsigned char *buffer, size_t size,
	160	const char *errmsg, int err);
	161
	162	/* Write SIZE bytes from BUFFER to DESCRIPTOR at file offset OFFSET.
	163	Return non-zero on success. On failure return 0 and set *ERRMSG
	164	and ERR. /
	165
	166	extern int
	167	simple_object_internal_write (int descriptor, off_t offset,
	168	const unsigned char *buffer, size_t size,
	169	const char *errmsg, int err);
	170
	171	/* Define ulong_type as an unsigned 64-bit type if available.
	172	Otherwise just make it unsigned long. */
	173
	174	#ifdef UNSIGNED_64BIT_TYPE
	175	__extension__ typedef UNSIGNED_64BIT_TYPE ulong_type;
	176	#else
	177	typedef unsigned long ulong_type;
	178	#endif
	179
	180	/* Fetch a big-endian 16-bit value. */
	181
	182	static inline unsigned short
	183	simple_object_fetch_big_16 (const unsigned char *buf)
	184	{
	185	return ((unsigned short) buf[0] << 8) \| (unsigned short) buf[1];
	186	}
	187
	188	/* Fetch a little-endian 16-bit value. */
	189
	190	static inline unsigned short
	191	simple_object_fetch_little_16 (const unsigned char *buf)
	192	{
	193	return ((unsigned short) buf[1] << 8) \| (unsigned short) buf[0];
	194	}
	195
	196	/* Fetch a big-endian 32-bit value. */
	197
	198	static inline unsigned int
	199	simple_object_fetch_big_32 (const unsigned char *buf)
	200	{
	201	return (((unsigned int) buf[0] << 24)
	202	\| ((unsigned int) buf[1] << 16)
	203	\| ((unsigned int) buf[2] << 8)
	204	\| (unsigned int) buf[3]);
	205	}
	206
	207	/* Fetch a little-endian 32-bit value. */
	208
	209	static inline unsigned int
	210	simple_object_fetch_little_32 (const unsigned char *buf)
	211	{
	212	return (((unsigned int) buf[3] << 24)
	213	\| ((unsigned int) buf[2] << 16)
	214	\| ((unsigned int) buf[1] << 8)
	215	\| (unsigned int) buf[0]);
216	}
217
218	/* Fetch a big-endian 32-bit value as a ulong_type. */
219
220	static inline ulong_type
221	simple_object_fetch_big_32_ulong (const unsigned char *buf)
222	{
223	return (ulong_type) simple_object_fetch_big_32 (buf);
224	}
225
226	/* Fetch a little-endian 32-bit value as a ulong_type. */
227
228	static inline ulong_type
229	simple_object_fetch_little_32_ulong (const unsigned char *buf)
230	{
231	return (ulong_type) simple_object_fetch_little_32 (buf);
232	}
233
234	#ifdef UNSIGNED_64BIT_TYPE
235
236	/* Fetch a big-endian 64-bit value. */
237
238	static inline ulong_type
239	simple_object_fetch_big_64 (const unsigned char *buf)
240	{
241	return (((ulong_type) buf[0] << 56)
242	\| ((ulong_type) buf[1] << 48)
243	\| ((ulong_type) buf[2] << 40)
244	\| ((ulong_type) buf[3] << 32)
245	\| ((ulong_type) buf[4] << 24)
246	\| ((ulong_type) buf[5] << 16)
247	\| ((ulong_type) buf[6] << 8)
248	\| (ulong_type) buf[7]);
249	}
250
251	/* Fetch a little-endian 64-bit value. */
252
253	static inline ulong_type
254	simple_object_fetch_little_64 (const unsigned char *buf)
255	{
256	return (((ulong_type) buf[7] << 56)
257	\| ((ulong_type) buf[6] << 48)
258	\| ((ulong_type) buf[5] << 40)
259	\| ((ulong_type) buf[4] << 32)
260	\| ((ulong_type) buf[3] << 24)
261	\| ((ulong_type) buf[2] << 16)
262	\| ((ulong_type) buf[1] << 8)
263	\| (ulong_type) buf[0]);
264	}
265
266	#endif
267
268	/* Store a big-endian 16-bit value. */
269
270	static inline void
271	simple_object_set_big_16 (unsigned char *buf, unsigned short val)
272	{
273	buf[0] = (val >> 8) & 0xff;
274	buf[1] = val & 0xff;
275	}
276
277	/* Store a little-endian 16-bit value. */
278
279	static inline void
280	simple_object_set_little_16 (unsigned char *buf, unsigned short val)
281	{
282	buf[1] = (val >> 8) & 0xff;
283	buf[0] = val & 0xff;
284	}
285
286	/* Store a big-endian 32-bit value. */
287
288	static inline void
289	simple_object_set_big_32 (unsigned char *buf, unsigned int val)
290	{
291	buf[0] = (val >> 24) & 0xff;
292	buf[1] = (val >> 16) & 0xff;
293	buf[2] = (val >> 8) & 0xff;
294	buf[3] = val & 0xff;
295	}
296
297	/* Store a little-endian 32-bit value. */
298
299	static inline void
300	simple_object_set_little_32 (unsigned char *buf, unsigned int val)
301	{
302	buf[3] = (val >> 24) & 0xff;
303	buf[2] = (val >> 16) & 0xff;
304	buf[1] = (val >> 8) & 0xff;
305	buf[0] = val & 0xff;
306	}
307
308	/* Store a big-endian 32-bit value coming in as a ulong_type. */
309
310	static inline void
311	simple_object_set_big_32_ulong (unsigned char *buf, ulong_type val)
312	{
313	simple_object_set_big_32 (buf, val);
314	}
315
316	/* Store a little-endian 32-bit value coming in as a ulong_type. */
317
318	static inline void
319	simple_object_set_little_32_ulong (unsigned char *buf, ulong_type val)
320	{
321	simple_object_set_little_32 (buf, val);
322	}
323
324	#ifdef UNSIGNED_64BIT_TYPE
325
326	/* Store a big-endian 64-bit value. */
327
328	static inline void
329	simple_object_set_big_64 (unsigned char *buf, ulong_type val)
330	{
331	buf[0] = (val >> 56) & 0xff;
332	buf[1] = (val >> 48) & 0xff;
333	buf[2] = (val >> 40) & 0xff;
334	buf[3] = (val >> 32) & 0xff;
335	buf[4] = (val >> 24) & 0xff;
336	buf[5] = (val >> 16) & 0xff;
337	buf[6] = (val >> 8) & 0xff;
338	buf[7] = val & 0xff;
339	}
340
341	/* Store a little-endian 64-bit value. */
342
343	static inline void
344	simple_object_set_little_64 (unsigned char *buf, ulong_type val)
345	{
346	buf[7] = (val >> 56) & 0xff;
347	buf[6] = (val >> 48) & 0xff;
348	buf[5] = (val >> 40) & 0xff;
349	buf[4] = (val >> 32) & 0xff;
350	buf[3] = (val >> 24) & 0xff;
351	buf[2] = (val >> 16) & 0xff;
352	buf[1] = (val >> 8) & 0xff;
353	buf[0] = val & 0xff;
354	}
355
356	#endif