ext/libelf/libelf_convert.m4

/*-
 * Copyright (c) 2006 Joseph Koshy
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>

#include <assert.h>
#include <string.h>

#include "elf32.h"
#include "elf64.h"
#include "libelf.h"
#include "_libelf.h"

/* WARNING: GENERATED FROM __file__. */

/*
 * Macros to swap various integral quantities.
 */

#define	SWAP_HALF(X) 	do {						\
		uint16_t _x = (uint16_t) (X);				\
		uint16_t _t = _x & 0xFF;				\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		(X) = _t;						\
	} while (0)
#define	SWAP_WORD(X) 	do {						\
		uint32_t _x = (uint32_t) (X);				\
		uint32_t _t = _x & 0xFF;				\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		(X) = _t;						\
	} while (0)
#define	SWAP_ADDR32(X)	SWAP_WORD(X)
#define	SWAP_OFF32(X)	SWAP_WORD(X)
#define	SWAP_SWORD(X)	SWAP_WORD(X)
#define	SWAP_WORD64(X)	do {						\
		uint64_t _x = (uint64_t) (X);				\
		uint64_t _t = _x & 0xFF;				\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		_t <<= 8; _x >>= 8; _t |= _x & 0xFF;			\
		(X) = _t;						\
	} while (0)
#define	SWAP_ADDR64(X)	SWAP_WORD64(X)
#define	SWAP_LWORD(X)	SWAP_WORD64(X)
#define	SWAP_OFF64(X)	SWAP_WORD64(X)
#define	SWAP_SXWORD(X)	SWAP_WORD64(X)
#define	SWAP_XWORD(X)	SWAP_WORD64(X)

/*
 * Write out various integral values.  The destination pointer could
 * be unaligned.  Values are written out in native byte order.  The
 * destination pointer is incremented after the write.
 */
#define	WRITE_BYTE(P,X) do {						\
		unsigned char *const _p = (unsigned char *) (P);	\
		_p[0]		= (unsigned char) (X);			\
		(P)		= _p + 1;				\
	} while (0)
#define	WRITE_HALF(P,X)	do {						\
		uint16_t _t	= (X);					\
		unsigned char *const _p	= (unsigned char *) (P);	\
		unsigned const char *const _q = (unsigned char *) &_t;	\
		_p[0]		= _q[0];				\
		_p[1]		= _q[1];				\
		(P) 		= _p + 2;				\
	} while (0)
#define	WRITE_WORD(P,X)	do {						\
		uint32_t _t	= (X);					\
		unsigned char *const _p	= (unsigned char *) (P);	\
		unsigned const char *const _q = (unsigned char *) &_t;	\
		_p[0]		= _q[0];				\
		_p[1]		= _q[1];				\
		_p[2]		= _q[2];				\
		_p[3]		= _q[3];				\
		(P)		= _p + 4;				\
	} while (0)
#define	WRITE_ADDR32(P,X)	WRITE_WORD(P,X)
#define	WRITE_OFF32(P,X)	WRITE_WORD(P,X)
#define	WRITE_SWORD(P,X)	WRITE_WORD(P,X)
#define	WRITE_WORD64(P,X)	do {					\
		uint64_t _t	= (X);					\
		unsigned char *const _p	= (unsigned char *) (P);	\
		unsigned const char *const _q = (unsigned char *) &_t;	\
		_p[0]		= _q[0];				\
		_p[1]		= _q[1];				\
		_p[2]		= _q[2];				\
		_p[3]		= _q[3];				\
		_p[4]		= _q[4];				\
		_p[5]		= _q[5];				\
		_p[6]		= _q[6];				\
		_p[7]		= _q[7];				\
		(P)		= _p + 8;				\
	} while (0)
#define	WRITE_ADDR64(P,X)	WRITE_WORD64(P,X)
#define	WRITE_LWORD(P,X)	WRITE_WORD64(P,X)
#define	WRITE_OFF64(P,X)	WRITE_WORD64(P,X)
#define	WRITE_SXWORD(P,X)	WRITE_WORD64(P,X)
#define	WRITE_XWORD(P,X)	WRITE_WORD64(P,X)
#define	WRITE_IDENT(P,X)	do {					\
		(void) memcpy((P), (X), sizeof((X)));			\
		(P)		= (P) + EI_NIDENT;			\
	} while (0)

/*
 * Read in various integral values.  The source pointer could be
 * unaligned.  Values are read in in native byte order.  The source
 * pointer is incremented appropriately.
 */

#define	READ_BYTE(P,X)	do {						\
		const unsigned char *const _p =				\
			(const unsigned char *) (P);			\
		(X)		= _p[0];				\
		(P)		= (P) + 1;				\
	} while (0)
#define	READ_HALF(P,X)	do {						\
		uint16_t _t;						\
		unsigned char *const _q = (unsigned char *) &_t;	\
		const unsigned char *const _p =				\
			(const unsigned char *) (P);			\
		_q[0]		= _p[0];				\
		_q[1]		= _p[1];				\
		(P)		= (P) + 2;				\
		(X)		= _t;					\
	} while (0)
#define	READ_WORD(P,X)	do {						\
		uint32_t _t;						\
		unsigned char *const _q = (unsigned char *) &_t;	\
		const unsigned char *const _p =				\
			(const unsigned char *) (P);			\
		_q[0]		= _p[0];				\
		_q[1]		= _p[1];				\
		_q[2]		= _p[2];				\
		_q[3]		= _p[3];				\
		(P)		= (P) + 4;				\
		(X)		= _t;					\
	} while (0)
#define	READ_ADDR32(P,X)	READ_WORD(P,X)
#define	READ_OFF32(P,X)		READ_WORD(P,X)
#define	READ_SWORD(P,X)		READ_WORD(P,X)
#define	READ_WORD64(P,X)	do {					\
		uint64_t _t;						\
		unsigned char *const _q = (unsigned char *) &_t;	\
		const unsigned char *const _p =				\
			(const unsigned char *) (P);			\
		_q[0]		= _p[0];				\
		_q[1]		= _p[1];				\
		_q[2]		= _p[2];				\
		_q[3]		= _p[3];				\
		_q[4]		= _p[4];				\
		_q[5]		= _p[5];				\
		_q[6]		= _p[6];				\
		_q[7]		= _p[7];				\
		(P)		= (P) + 8;				\
		(X)		= _t;					\
	} while (0)
#define	READ_ADDR64(P,X)	READ_WORD64(P,X)
#define	READ_LWORD(P,X)		READ_WORD64(P,X)
#define	READ_OFF64(P,X)		READ_WORD64(P,X)
#define	READ_SXWORD(P,X)	READ_WORD64(P,X)
#define	READ_XWORD(P,X)		READ_WORD64(P,X)
#define	READ_IDENT(P,X)		do {					\
		(void) memcpy((X), (P), sizeof((X)));			\
		(P)		= (P) + EI_NIDENT;			\
	} while (0)

#define	ROUNDUP2(V,N)	(V) = ((((V) + (N) - 1)) & ~((N) - 1))

divert(-1)

/*
 * Generate conversion routines for converting between in-memory and
 * file representations of Elf data structures.
 *
 * `In-memory' representations of an Elf data structure use natural
 * alignments and native byte ordering.  This allows arithmetic and
 * casting to work as expected.  On the other hand the `file'
 * representation of an ELF data structure could be packed tighter
 * than its `in-memory' representation, and could be of a differing
 * byte order.  An additional complication is that `ar' only pads data
 * to even addresses and so ELF archive member data being read from
 * inside an `ar' archive could end up at misaligned memory addresses.
 *
 * Consequently, casting the `char *' pointers that point to memory
 * representations (i.e., source pointers for the *_tof() functions
 * and the destination pointers for the *_tom() functions), is safe,
 * as these pointers should be correctly aligned for the memory type
 * already.  However, pointers to file representations have to be
 * treated as being potentially unaligned and no casting can be done.
 */

include(SRCDIR`/elf_types.m4')

/*
 * `IGNORE'_* flags turn off generation of template code.
 */

define(`IGNORE',
  `define(IGNORE_$1`'32,	1)
   define(IGNORE_$1`'64,	1)')

IGNORE(MOVEP)
IGNORE(NOTE)

define(IGNORE_BYTE,		1)	/* 'lator, leave 'em bytes alone */
define(IGNORE_NOTE,		1)
define(IGNORE_SXWORD32,		1)
define(IGNORE_XWORD32,		1)

/*
 * `BASE'_XXX flags cause class agnostic template functions
 * to be generated.
 */

define(`BASE_BYTE',	1)
define(`BASE_HALF',	1)
define(`BASE_NOTE',	1)
define(`BASE_WORD',	1)
define(`BASE_LWORD',	1)
define(`BASE_SWORD',	1)
define(`BASE_XWORD',	1)
define(`BASE_SXWORD',	1)

/*
 * `SIZEDEP'_XXX flags cause 32/64 bit variants to be generated
 * for each primitive type.
 */

define(`SIZEDEP_ADDR',	1)
define(`SIZEDEP_OFF',	1)

/*
 * `Primitive' ELF types are those that are an alias for an integral
 * type.  They have no internal structure. These can be copied using
 * a `memcpy()', and byteswapped in straightforward way.
 *
 * Macro use:
 * `$1': Name of the ELF type.
 * `$2': C structure name suffix
 * `$3': ELF class specifier for symbols, one of [`', `32', `64']
 * `$4': ELF class specifier for types, one of [`32', `64']
 */
define(`MAKEPRIM_TO_F',`
static void
libelf_cvt_$1$3_tof(char *dst, char *src, size_t count, int byteswap)
{
	Elf$4_$2 t, *s = (Elf$4_$2 *) (uintptr_t) src;
	size_t c;

	if (dst == src && !byteswap)
		return;

	if (!byteswap) {
		(void) memcpy(dst, src, count * sizeof(*s));
		return;
	}

	for (c = 0; c < count; c++) {
		t = *s++;
		SWAP_$1$3(t);
		WRITE_$1$3(dst,t);
	}
}
')

define(`MAKEPRIM_TO_M',`
static void
libelf_cvt_$1$3_tom(char *dst, char *src, size_t count, int byteswap)
{
	Elf$4_$2 t, *d = (Elf$4_$2 *) (uintptr_t) dst;
	size_t c;

	if (dst == src && !byteswap)
		return;

	if (!byteswap) {
		(void) memcpy(dst, src, count * sizeof(*d));
		return;
	}

	for (c = 0; c < count; c++) {
		READ_$1$3(src,t);
		SWAP_$1$3(t);
		*d++ = t;
	}
}
')

define(`SWAP_FIELD',
  `ifdef(`IGNORE_'$2,`',
    `ifelse(BASE_$2,1,
      `SWAP_$2(t.$1);
			',
      `ifelse($2,BYTE,`',
        `ifelse($2,IDENT,`',
          `SWAP_$2'SZ()`(t.$1);
			')')')')')
define(`SWAP_MEMBERS',
  `ifelse($#,1,`/**/',
     `SWAP_FIELD($1)SWAP_MEMBERS(shift($@))')')

define(`SWAP_STRUCT',
  `pushdef(`SZ',$2)/* Swap an Elf$2_$1 */
			SWAP_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')')

define(`WRITE_FIELD',
  `ifelse(BASE_$2,1,
    `WRITE_$2(dst,t.$1);
		',
    `ifelse($2,IDENT,
      `WRITE_$2(dst,t.$1);
		',
      `WRITE_$2'SZ()`(dst,t.$1);
		')')')
define(`WRITE_MEMBERS',
  `ifelse($#,1,`/**/',
    `WRITE_FIELD($1)WRITE_MEMBERS(shift($@))')')

define(`WRITE_STRUCT',
  `pushdef(`SZ',$2)/* Write an Elf$2_$1 */
		WRITE_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')')

define(`READ_FIELD',
  `ifelse(BASE_$2,1,
    `READ_$2(s,t.$1);
		',
    `ifelse($2,IDENT,
      `READ_$2(s,t.$1);
		',
      `READ_$2'SZ()`(s,t.$1);
		')')')

define(`READ_MEMBERS',
  `ifelse($#,1,`/**/',
    `READ_FIELD($1)READ_MEMBERS(shift($@))')')

define(`READ_STRUCT',
  `pushdef(`SZ',$2)/* Read an Elf$2_$1 */
		READ_MEMBERS(Elf$2_$1_DEF)popdef(`SZ')')

/*
 * Converters for non-integral ELF data structures.
 *
 * When converting data to file representation, the source pointer
 * will be naturally aligned for a data structure's in-memory
 * representation.  When converting data to memory, the destination
 * pointer will be similarly aligned.
 *
 * For in-place conversions, when converting to file representations,
 * the source buffer is large enough to hold `file' data.  When
 * converting from file to memory, we need to be careful to work
 * `backwards', to avoid overwriting unconverted data.
 *
 * Macro use:
 * `$1': Name of the ELF type.
 * `$2': C structure name suffix.
 * `$3': ELF class specifier, one of [`', `32', `64']
 */

define(`MAKE_TO_F',
  `ifdef(`IGNORE_'$1$3,`',`
static void
libelf_cvt$3_$1_tof(char *dst, char *src, size_t count, int byteswap)
{
	Elf$3_$2	t, *s;
	size_t c;

	s = (Elf$3_$2 *) (uintptr_t) src;
	for (c = 0; c < count; c++) {
		t = *s++;
		if (byteswap) {
			SWAP_STRUCT($2,$3)
		}
		WRITE_STRUCT($2,$3)
	}
}
')')

define(`MAKE_TO_M',
  `ifdef(`IGNORE_'$1$3,`',`
static void
libelf_cvt$3_$1_tom(char *dst, char *src, size_t count, int byteswap)
{
	Elf$3_$2	 t, *d;
	unsigned char	*s,*s0;
	size_t		fsz;

	fsz = elf$3_fsize(ELF_T_$1, (size_t) 1, EV_CURRENT);
	d   = ((Elf$3_$2 *) (uintptr_t) dst) + (count - 1);
	s0  = (unsigned char *) src + (count - 1) * fsz;

	while (count--) {
		s = s0;
		READ_STRUCT($2,$3)
		if (byteswap) {
			SWAP_STRUCT($2,$3)
		}
		*d-- = t; s0 -= fsz;
	}
}
')')

/*
 * Make type convertor functions from the type definition
 * of the ELF type:
 * - if the type is a base (i.e., `primitive') type:
 *   - if it is marked as to be ignored (i.e., `IGNORE_'TYPE)
 *     is defined, we skip the code generation step.
 *   - if the type is declared as `SIZEDEP', then 32 and 64 bit
 *     variants of the conversion functions are generated.
 *   - otherwise a 32 bit variant is generated.
 * - if the type is a structure type, we generate 32 and 64 bit
 *   variants of the conversion functions.
 */

define(`MAKE_TYPE_CONVERTER',
  `ifdef(`BASE'_$1,
    `ifdef(`IGNORE_'$1,`',
      `MAKEPRIM_TO_F($1,$2,`',64)
       MAKEPRIM_TO_M($1,$2,`',64)')',
    `ifdef(`SIZEDEP_'$1,
      `MAKEPRIM_TO_F($1,$2,32,32)dnl
       MAKEPRIM_TO_M($1,$2,32,32)dnl
       MAKEPRIM_TO_F($1,$2,64,64)dnl
       MAKEPRIM_TO_M($1,$2,64,64)',
      `MAKE_TO_F($1,$2,32)dnl
       MAKE_TO_F($1,$2,64)dnl
       MAKE_TO_M($1,$2,32)dnl
       MAKE_TO_M($1,$2,64)')')
')

define(`MAKE_TYPE_CONVERTERS',
  `ifelse($#,1,`',
    `MAKE_TYPE_CONVERTER($1)MAKE_TYPE_CONVERTERS(shift($@))')')

divert(0)

/*
 * Sections of type ELF_T_BYTE are never byteswapped, consequently a
 * simple memcpy suffices for both directions of conversion.
 */

static void
libelf_cvt_BYTE_tox(char *dst, char *src, size_t count, int byteswap)
{
	(void) byteswap;
	if (dst != src)
		(void) memcpy(dst, src, count);
}

/*
 * Elf_Note structures comprise a fixed size header followed by variable
 * length strings.  The fixed size header needs to be byte swapped, but
 * not the strings.
 *
 * Argument `count' denotes the total number of bytes to be converted.
 */
static void
libelf_cvt_NOTE_tom(char *dst, char *src, size_t count, int byteswap)
{
	uint32_t namesz, descsz, type;
	Elf_Note *en;
	size_t sz;

	if (dst == src && !byteswap)
		return;

	if (!byteswap) {
		(void) memcpy(dst, src, count);
		return;
	}

	while (count > sizeof(Elf_Note)) {

		READ_WORD(src, namesz);
		READ_WORD(src, descsz);
		READ_WORD(src, type);

		if (byteswap) {
			SWAP_WORD(namesz);
			SWAP_WORD(descsz);
			SWAP_WORD(type);
		}

		en = (Elf_Note *) (uintptr_t) dst;
		en->n_namesz = namesz;
		en->n_descsz = descsz;
		en->n_type = type;

		dst += sizeof(Elf_Note);

		ROUNDUP2(namesz, 4);
		ROUNDUP2(descsz, 4);

		sz = namesz + descsz;

		if (count < sz)
			sz = count;

		(void) memcpy(dst, src, sz);

		src += sz;
		dst += sz;
		count -= sz;
	}
}

static void
libelf_cvt_NOTE_tof(char *dst, char *src, size_t count, int byteswap)
{
	uint32_t namesz, descsz, type;
	Elf_Note *en;
	size_t sz;

	if (dst == src && !byteswap)
		return;

	if (!byteswap) {
		(void) memcpy(dst, src, count);
		return;
	}

	while (count > sizeof(Elf_Note)) {

		en = (Elf_Note *) (uintptr_t) src;
		namesz = en->n_namesz;
		descsz = en->n_descsz;
		type = en->n_type;

		if (byteswap) {
			SWAP_WORD(namesz);
			SWAP_WORD(descsz);
			SWAP_WORD(type);
		}


		WRITE_WORD(dst, namesz);
		WRITE_WORD(dst, descsz);
		WRITE_WORD(dst, type);

		src += sizeof(Elf_Note);

		ROUNDUP2(namesz, 4);
		ROUNDUP2(descsz, 4);

		sz = namesz + descsz;

		if (count < sz)
			sz = count;

		(void) memcpy(dst, src, sz);

		src += sz;
		dst += sz;
		count -= sz;
	}
}

MAKE_TYPE_CONVERTERS(ELF_TYPE_LIST)

struct converters {
	void	(*tof32)(char *dst, char *src, size_t cnt, int byteswap);
	void	(*tom32)(char *dst, char *src, size_t cnt, int byteswap);
	void	(*tof64)(char *dst, char *src, size_t cnt, int byteswap);
	void	(*tom64)(char *dst, char *src, size_t cnt, int byteswap);
};

divert(-1)
define(`CONV',
  `ifdef(`IGNORE_'$1$2,
    `.$3$2 = NULL',
    `ifdef(`BASE_'$1,
      `ifdef(`IGNORE_'$1,
	`.$3$2 = NULL',
        `.$3$2 = libelf_cvt_$1_$3')',
      `ifdef(`SIZEDEP_'$1,
        `.$3$2 = libelf_cvt_$1$2_$3',
        `.$3$2 = libelf_cvt$2_$1_$3')')')')

define(`CONVERTER_NAME',
  `[ELF_T_$1] = {
        CONV($1,32,tof), CONV($1,32,tom),
        CONV($1,64,tof), CONV($1,64,tom) },')')

define(`CONVERTER_NAMES',
  `ifelse($#,1,`',
    `CONVERTER_NAME($1)CONVERTER_NAMES(shift($@))')')

undefine(`IGNORE_BYTE32')
undefine(`IGNORE_BYTE64')
divert(0)

static struct converters cvt[ELF_T_NUM] = {
CONVERTER_NAMES(ELF_TYPE_LIST)

	/*
	 * Types that needs hand-coded converters follow.
	 */

	[ELF_T_BYTE] = {
		.tof32 = libelf_cvt_BYTE_tox,
		.tom32 = libelf_cvt_BYTE_tox,
		.tof64 = libelf_cvt_BYTE_tox,
		.tom64 = libelf_cvt_BYTE_tox
	},
	[ELF_T_NOTE] = {
		.tof32 = libelf_cvt_NOTE_tof,
		.tom32 = libelf_cvt_NOTE_tom,
		.tof64 = libelf_cvt_NOTE_tof,
		.tom64 = libelf_cvt_NOTE_tom
	}
};

void (*_libelf_get_translator(Elf_Type t, int direction, int elfclass))
 (char *_dst, char *_src, size_t _cnt, int _byteswap)
{
	assert(elfclass == ELFCLASS32 || elfclass == ELFCLASS64);
	assert(direction == ELF_TOFILE || direction == ELF_TOMEMORY);

	if (t >= ELF_T_NUM ||
	    (elfclass != ELFCLASS32 && elfclass != ELFCLASS64) ||
	    (direction != ELF_TOFILE && direction != ELF_TOMEMORY))
		return (NULL);

	return ((elfclass == ELFCLASS32) ?
	    (direction == ELF_TOFILE ? cvt[t].tof32 : cvt[t].tom32) :
	    (direction == ELF_TOFILE ? cvt[t].tof64 : cvt[t].tom64));
}