summaryrefslogtreecommitdiff
path: root/test/libelf/tset/common/xlate_template.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/libelf/tset/common/xlate_template.c')
-rw-r--r--test/libelf/tset/common/xlate_template.c1825
1 files changed, 1825 insertions, 0 deletions
diff --git a/test/libelf/tset/common/xlate_template.c b/test/libelf/tset/common/xlate_template.c
new file mode 100644
index 0000000000000..84bdb4c1b97ab
--- /dev/null
+++ b/test/libelf/tset/common/xlate_template.c
@@ -0,0 +1,1825 @@
+/*-
+ * Copyright (c) 2006,2010-2011 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.
+ *
+ * $Id: xlate_template.c 2586 2012-09-15 14:32:47Z jkoshy $
+ */
+
+/*
+ * Boilerplate for testing the *_xlate() functions.
+ *
+ * Usage:
+ *
+ * #define TS_XLATESZ 32 (or 64)
+ * #include "xlate_template.c"
+ */
+
+#include <sys/param.h>
+#include <sys/cdefs.h>
+
+#define __XCONCAT(x,y) __CONCAT(x,y)
+#ifndef __XSTRING
+#define __XSTRING(x) __STRING(x)
+#endif
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define TS_XLATETOF __XCONCAT(elf,__XCONCAT(TS_XLATESZ,_xlatetof))
+#define TS_XLATETOM __XCONCAT(elf,__XCONCAT(TS_XLATESZ,_xlatetom))
+
+#define BYTE_VAL 0xFF
+#define BYTE_SEQ_LSB 0xFF,
+#define BYTE_SEQ_MSB 0xFF,
+
+#define HALF_VAL 0xFEDC
+#define HALF_SEQ_LSB 0xDC,0xFE,
+#define HALF_SEQ_MSB 0xFE,0xDC,
+
+#define WORD_VAL 0xFEDCBA98UL
+#define WORD_SEQ_LSB 0x98,0xBA,0xDC,0xFE,
+#define WORD_SEQ_MSB 0xFE,0xDC,0xBA,0x98,
+
+#define QUAD_VAL 0xFEDCBA9876543210ULL
+#define QUAD_SEQ_LSB 0x10,0x32,0x54,0x76,\
+ 0x98,0xBA,0xDC,0xFE,
+#define QUAD_SEQ_MSB 0xFE,0xDC,0xBA,0x98,\
+ 0x76,0x54,0x32,0x10,
+
+#define IDENT_BYTES 46,33,46,64,46,35,46,36,46,37,46,94,46,38,46,42
+#define IDENT_VAL { IDENT_BYTES }
+#define IDENT_SEQ_LSB IDENT_BYTES,
+#define IDENT_SEQ_MSB IDENT_BYTES,
+
+
+#define TYPEDEFNAME(E,N) __XCONCAT(__XCONCAT(td_, \
+ __XCONCAT(E,TS_XLATESZ)), __XCONCAT(_,N))
+#define TYPEDEFINITION(E,N) __XCONCAT(ELF_TYPE_E,__XCONCAT(TS_XLATESZ, \
+ __XCONCAT(_, N)))
+#define CHKFNNAME(N) __XCONCAT(__XCONCAT(td_chk_,TS_XLATESZ), \
+ __XCONCAT(_,N))
+#define MEMSIZENAME(N) __XCONCAT(N,__XCONCAT(TS_XLATESZ,_SIZE))
+#define MEMSTRUCTNAME(N) __XCONCAT(N,__XCONCAT(TS_XLATESZ,_mem))
+
+/*
+ * Definitions of 32 bit ELF file structures.
+ */
+
+#define ELF_TYPE_E32_CAP() \
+ MEMBER(c_tag, WORD) \
+ MEMBER(c_un.c_val, WORD)
+
+#define ELF_TYPE_E32_DYN() \
+ MEMBER(d_tag, WORD) \
+ MEMBER(d_un.d_val, WORD)
+
+#define ELF_TYPE_E32_EHDR() \
+ MEMBER(e_ident, IDENT) \
+ MEMBER(e_type, HALF) \
+ MEMBER(e_machine, HALF) \
+ MEMBER(e_version, WORD) \
+ MEMBER(e_entry, WORD) \
+ MEMBER(e_phoff, WORD) \
+ MEMBER(e_shoff, WORD) \
+ MEMBER(e_flags, WORD) \
+ MEMBER(e_ehsize, HALF) \
+ MEMBER(e_phentsize, HALF) \
+ MEMBER(e_phnum, HALF) \
+ MEMBER(e_shentsize, HALF) \
+ MEMBER(e_shnum, HALF) \
+ MEMBER(e_shstrndx, HALF)
+
+#define ELF_TYPE_E32_MOVE() \
+ MEMBER(m_value, QUAD) \
+ MEMBER(m_info, WORD) \
+ MEMBER(m_poffset, WORD) \
+ MEMBER(m_repeat, HALF) \
+ MEMBER(m_stride, HALF)
+
+#define ELF_TYPE_E32_PHDR() \
+ MEMBER(p_type, WORD) \
+ MEMBER(p_offset, WORD) \
+ MEMBER(p_vaddr, WORD) \
+ MEMBER(p_paddr, WORD) \
+ MEMBER(p_filesz, WORD) \
+ MEMBER(p_memsz, WORD) \
+ MEMBER(p_flags, WORD) \
+ MEMBER(p_align, WORD)
+
+#define ELF_TYPE_E32_REL() \
+ MEMBER(r_offset, WORD) \
+ MEMBER(r_info, WORD)
+
+#define ELF_TYPE_E32_RELA() \
+ MEMBER(r_offset, WORD) \
+ MEMBER(r_info, WORD) \
+ MEMBER(r_addend, WORD)
+
+#define ELF_TYPE_E32_SHDR() \
+ MEMBER(sh_name, WORD) \
+ MEMBER(sh_type, WORD) \
+ MEMBER(sh_flags, WORD) \
+ MEMBER(sh_addr, WORD) \
+ MEMBER(sh_offset, WORD) \
+ MEMBER(sh_size, WORD) \
+ MEMBER(sh_link, WORD) \
+ MEMBER(sh_info, WORD) \
+ MEMBER(sh_addralign, WORD) \
+ MEMBER(sh_entsize, WORD)
+
+#define ELF_TYPE_E32_SYM() \
+ MEMBER(st_name, WORD) \
+ MEMBER(st_value, WORD) \
+ MEMBER(st_size, WORD) \
+ MEMBER(st_info, BYTE) \
+ MEMBER(st_other, BYTE) \
+ MEMBER(st_shndx, HALF)
+
+#define ELF_TYPE_E32_SYMINFO() \
+ MEMBER(si_boundto, HALF) \
+ MEMBER(si_flags, HALF)
+
+/*
+ * Definitions of 64 bit ELF file structures.
+ */
+
+#define ELF_TYPE_E64_CAP() \
+ MEMBER(c_tag, QUAD) \
+ MEMBER(c_un.c_val, QUAD)
+
+#define ELF_TYPE_E64_DYN() \
+ MEMBER(d_tag, QUAD) \
+ MEMBER(d_un.d_val, QUAD)
+
+#define ELF_TYPE_E64_EHDR() \
+ MEMBER(e_ident, IDENT) \
+ MEMBER(e_type, HALF) \
+ MEMBER(e_machine, HALF) \
+ MEMBER(e_version, WORD) \
+ MEMBER(e_entry, QUAD) \
+ MEMBER(e_phoff, QUAD) \
+ MEMBER(e_shoff, QUAD) \
+ MEMBER(e_flags, WORD) \
+ MEMBER(e_ehsize, HALF) \
+ MEMBER(e_phentsize, HALF) \
+ MEMBER(e_phnum, HALF) \
+ MEMBER(e_shentsize, HALF) \
+ MEMBER(e_shnum, HALF) \
+ MEMBER(e_shstrndx, HALF)
+
+#define ELF_TYPE_E64_MOVE() \
+ MEMBER(m_value, QUAD) \
+ MEMBER(m_info, QUAD) \
+ MEMBER(m_poffset, QUAD) \
+ MEMBER(m_repeat, HALF) \
+ MEMBER(m_stride, HALF)
+
+#define ELF_TYPE_E64_PHDR() \
+ MEMBER(p_type, WORD) \
+ MEMBER(p_flags, WORD) \
+ MEMBER(p_offset, QUAD) \
+ MEMBER(p_vaddr, QUAD) \
+ MEMBER(p_paddr, QUAD) \
+ MEMBER(p_filesz, QUAD) \
+ MEMBER(p_memsz, QUAD) \
+ MEMBER(p_align, QUAD)
+
+#define ELF_TYPE_E64_REL() \
+ MEMBER(r_offset, QUAD) \
+ MEMBER(r_info, QUAD)
+
+#define ELF_TYPE_E64_RELA() \
+ MEMBER(r_offset, QUAD) \
+ MEMBER(r_info, QUAD) \
+ MEMBER(r_addend, QUAD)
+
+#define ELF_TYPE_E64_SHDR() \
+ MEMBER(sh_name, WORD) \
+ MEMBER(sh_type, WORD) \
+ MEMBER(sh_flags, QUAD) \
+ MEMBER(sh_addr, QUAD) \
+ MEMBER(sh_offset, QUAD) \
+ MEMBER(sh_size, QUAD) \
+ MEMBER(sh_link, WORD) \
+ MEMBER(sh_info, WORD) \
+ MEMBER(sh_addralign, QUAD) \
+ MEMBER(sh_entsize, QUAD)
+
+#define ELF_TYPE_E64_SYM() \
+ MEMBER(st_name, WORD) \
+ MEMBER(st_info, BYTE) \
+ MEMBER(st_other, BYTE) \
+ MEMBER(st_shndx, HALF) \
+ MEMBER(st_value, QUAD) \
+ MEMBER(st_size, QUAD) \
+
+#define ELF_TYPE_E64_SYMINFO() \
+ MEMBER(si_boundto, HALF) \
+ MEMBER(si_flags, HALF)
+
+static unsigned char TYPEDEFNAME(L,CAP)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,CAP)()
+};
+static unsigned char TYPEDEFNAME(M,CAP)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,CAP)()
+};
+
+static unsigned char TYPEDEFNAME(L,DYN)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,DYN)()
+};
+static unsigned char TYPEDEFNAME(M,DYN)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,DYN)()
+};
+
+static unsigned char TYPEDEFNAME(L,EHDR)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,EHDR)()
+};
+static unsigned char TYPEDEFNAME(M,EHDR)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,EHDR)()
+};
+
+static unsigned char TYPEDEFNAME(L,HALF)[] = {
+ HALF_SEQ_LSB
+};
+static unsigned char TYPEDEFNAME(M,HALF)[] = {
+ HALF_SEQ_MSB
+};
+
+static unsigned char TYPEDEFNAME(L,MOVE)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,MOVE)()
+};
+static unsigned char TYPEDEFNAME(M,MOVE)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,MOVE)()
+};
+
+static unsigned char TYPEDEFNAME(L,PHDR)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,PHDR)()
+};
+static unsigned char TYPEDEFNAME(M,PHDR)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,PHDR)()
+};
+
+static unsigned char TYPEDEFNAME(L,REL)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,REL)()
+};
+static unsigned char TYPEDEFNAME(M,REL)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,REL)()
+};
+
+static unsigned char TYPEDEFNAME(L,RELA)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,RELA)()
+};
+static unsigned char TYPEDEFNAME(M,RELA)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,RELA)()
+};
+
+static unsigned char TYPEDEFNAME(L,SHDR)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,SHDR)()
+};
+static unsigned char TYPEDEFNAME(M,SHDR)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,SHDR)()
+};
+
+static unsigned char TYPEDEFNAME(L,SYM)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,SYM)()
+};
+static unsigned char TYPEDEFNAME(M,SYM)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,SYM)()
+};
+
+static unsigned char TYPEDEFNAME(L,SYMINFO)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_LSB
+ TYPEDEFINITION(L,SYMINFO)()
+};
+static unsigned char TYPEDEFNAME(M,SYMINFO)[] = {
+#undef MEMBER
+#define MEMBER(N,K) K##_SEQ_MSB
+ TYPEDEFINITION(M,SYMINFO)()
+};
+
+static unsigned char TYPEDEFNAME(L,QUAD)[] = {
+ QUAD_SEQ_LSB
+};
+
+static unsigned char TYPEDEFNAME(M,QUAD)[] = {
+ QUAD_SEQ_MSB
+};
+
+static unsigned char TYPEDEFNAME(L,WORD)[] = {
+ WORD_SEQ_LSB
+};
+static unsigned char TYPEDEFNAME(M,WORD)[] = {
+ WORD_SEQ_MSB
+};
+
+#if TS_XLATESZ == 32
+/*
+ * 32 bit reference structures.
+ */
+
+#define td_L32_ADDR td_L32_WORD
+#define td_M32_ADDR td_M32_WORD
+#define td_L32_SWORD td_L32_WORD
+#define td_M32_SWORD td_M32_WORD
+#define td_L32_OFF td_L32_WORD
+#define td_M32_OFF td_M32_WORD
+
+static Elf32_Addr MEMSTRUCTNAME(ADDR) = WORD_VAL;
+#define ADDR32_SIZE sizeof(Elf32_Addr)
+
+static Elf32_Cap MEMSTRUCTNAME(CAP) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_CAP()
+};
+#define CAP32_SIZE sizeof(Elf32_Cap)
+
+static Elf32_Dyn MEMSTRUCTNAME(DYN) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_DYN()
+};
+#define DYN32_SIZE sizeof(Elf32_Dyn)
+
+static Elf32_Ehdr MEMSTRUCTNAME(EHDR) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_EHDR()
+};
+#define EHDR32_SIZE sizeof(Elf32_Ehdr)
+
+static Elf32_Half MEMSTRUCTNAME(HALF) = HALF_VAL;
+#define HALF32_SIZE sizeof(Elf32_Half)
+
+static Elf32_Move MEMSTRUCTNAME(MOVE) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_MOVE()
+};
+#define MOVE32_SIZE sizeof(Elf32_Move)
+
+static Elf32_Off MEMSTRUCTNAME(OFF) = WORD_VAL;
+#define OFF32_SIZE sizeof(Elf32_Off)
+
+static Elf32_Phdr MEMSTRUCTNAME(PHDR) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_PHDR()
+};
+#define PHDR32_SIZE sizeof(Elf32_Phdr)
+
+static Elf32_Rel MEMSTRUCTNAME(REL) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_REL()
+};
+#define REL32_SIZE sizeof(Elf32_Rel)
+
+static Elf32_Rela MEMSTRUCTNAME(RELA) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_RELA()
+};
+#define RELA32_SIZE sizeof(Elf32_Rela)
+
+static Elf32_Shdr MEMSTRUCTNAME(SHDR) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_SHDR()
+};
+#define SHDR32_SIZE sizeof(Elf32_Shdr)
+
+static Elf32_Sword MEMSTRUCTNAME(SWORD) = WORD_VAL;
+#define SWORD32_SIZE sizeof(Elf32_Sword)
+
+static Elf32_Sym MEMSTRUCTNAME(SYM) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_SYM()
+};
+#define SYM32_SIZE sizeof(Elf32_Sym)
+
+static Elf32_Syminfo MEMSTRUCTNAME(SYMINFO) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E32_SYMINFO()
+};
+#define SYMINFO32_SIZE sizeof(Elf32_Syminfo)
+
+static Elf32_Word MEMSTRUCTNAME(WORD) = WORD_VAL;
+#define WORD32_SIZE sizeof(Elf32_Word)
+
+#else
+/*
+ * 64 bit reference structures.
+ */
+
+#define td_L64_ADDR td_L64_QUAD
+#define td_M64_ADDR td_M64_QUAD
+#define td_L64_OFF td_L64_QUAD
+#define td_M64_OFF td_M64_QUAD
+#define td_L64_SWORD td_L64_WORD
+#define td_M64_SWORD td_M64_WORD
+#define td_L64_SXWORD td_L64_QUAD
+#define td_M64_SXWORD td_M64_QUAD
+#define td_L64_XWORD td_L64_QUAD
+#define td_M64_XWORD td_M64_QUAD
+
+static Elf64_Addr MEMSTRUCTNAME(ADDR) = QUAD_VAL;
+#define ADDR64_SIZE sizeof(Elf64_Addr)
+
+static Elf64_Cap MEMSTRUCTNAME(CAP) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_CAP()
+};
+#define CAP64_SIZE sizeof(Elf64_Cap)
+
+static Elf64_Dyn MEMSTRUCTNAME(DYN) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_DYN()
+};
+#define DYN64_SIZE sizeof(Elf64_Dyn)
+
+static Elf64_Ehdr MEMSTRUCTNAME(EHDR) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_EHDR()
+};
+#define EHDR64_SIZE sizeof(Elf64_Ehdr)
+
+static Elf64_Half MEMSTRUCTNAME(HALF) = HALF_VAL;
+#define HALF64_SIZE sizeof(Elf64_Half)
+
+static Elf64_Move MEMSTRUCTNAME(MOVE) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_MOVE()
+};
+#define MOVE64_SIZE sizeof(Elf64_Move)
+
+static Elf64_Phdr MEMSTRUCTNAME(PHDR) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_PHDR()
+};
+#define PHDR64_SIZE sizeof(Elf64_Phdr)
+
+static Elf64_Off MEMSTRUCTNAME(OFF) = QUAD_VAL;
+#define OFF64_SIZE sizeof(Elf64_Off)
+
+static Elf64_Rel MEMSTRUCTNAME(REL) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_REL()
+};
+#define REL64_SIZE sizeof(Elf64_Rel)
+
+static Elf64_Rela MEMSTRUCTNAME(RELA) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_RELA()
+};
+#define RELA64_SIZE sizeof(Elf64_Rela)
+
+static Elf64_Shdr MEMSTRUCTNAME(SHDR) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_SHDR()
+};
+#define SHDR64_SIZE sizeof(Elf64_Shdr)
+
+static Elf64_Sword MEMSTRUCTNAME(SWORD) = WORD_VAL;
+#define SWORD64_SIZE sizeof(Elf64_Sword)
+
+static Elf64_Sxword MEMSTRUCTNAME(SXWORD) = QUAD_VAL;
+#define SXWORD64_SIZE sizeof(Elf64_Sxword)
+
+static Elf64_Sym MEMSTRUCTNAME(SYM) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_SYM()
+};
+#define SYM64_SIZE sizeof(Elf64_Sym)
+
+static Elf64_Syminfo MEMSTRUCTNAME(SYMINFO) = {
+#undef MEMBER
+#define MEMBER(N,K) .N = K##_VAL ,
+ ELF_TYPE_E64_SYMINFO()
+};
+#define SYMINFO64_SIZE sizeof(Elf64_Syminfo)
+
+static Elf64_Word MEMSTRUCTNAME(WORD) = WORD_VAL;
+#define WORD64_SIZE sizeof(Elf64_Word)
+
+static Elf64_Xword MEMSTRUCTNAME(XWORD) = QUAD_VAL;
+#define XWORD64_SIZE sizeof(Elf64_Xword)
+
+#endif /* TS_XLATESZ == 32 */
+
+
+#ifndef _TESTDATA_STRUCT_
+#define _TESTDATA_STRUCT_ 1
+struct testdata {
+ char *tsd_name;
+ Elf_Type tsd_type;
+ void *tsd_mem;
+ size_t tsd_fsz;
+ size_t tsd_msz;
+ const unsigned char *tsd_lsb;
+ const unsigned char *tsd_msb;
+};
+#endif /*_TESTDATA_STRUCT_*/
+
+#define TESTDATASET __XCONCAT(tests,TS_XLATESZ)
+static struct testdata TESTDATASET [] = {
+#undef DEFINE_TEST_DATA
+#define DEFINE_TEST_DATA(N) { \
+ .tsd_name = #N, \
+ .tsd_type = ELF_T_##N, \
+ .tsd_fsz = sizeof(TYPEDEFNAME(L,N)), \
+ .tsd_msz = MEMSIZENAME(N), \
+ .tsd_mem = (void *) &MEMSTRUCTNAME(N), \
+ .tsd_lsb = TYPEDEFNAME(L,N), \
+ .tsd_msb = TYPEDEFNAME(M,N), \
+ }
+#if TS_XLATESZ == 32
+ DEFINE_TEST_DATA(ADDR),
+ DEFINE_TEST_DATA(CAP),
+ DEFINE_TEST_DATA(DYN),
+ DEFINE_TEST_DATA(EHDR),
+ DEFINE_TEST_DATA(HALF),
+ DEFINE_TEST_DATA(MOVE),
+ DEFINE_TEST_DATA(OFF),
+ DEFINE_TEST_DATA(PHDR),
+ DEFINE_TEST_DATA(REL),
+ DEFINE_TEST_DATA(RELA),
+ DEFINE_TEST_DATA(SHDR),
+ DEFINE_TEST_DATA(SWORD),
+ DEFINE_TEST_DATA(SYM),
+ DEFINE_TEST_DATA(SYMINFO),
+ DEFINE_TEST_DATA(WORD),
+#else
+ DEFINE_TEST_DATA(ADDR),
+ DEFINE_TEST_DATA(CAP),
+ DEFINE_TEST_DATA(DYN),
+ DEFINE_TEST_DATA(EHDR),
+ DEFINE_TEST_DATA(HALF),
+ DEFINE_TEST_DATA(MOVE),
+ DEFINE_TEST_DATA(OFF),
+ DEFINE_TEST_DATA(PHDR),
+ DEFINE_TEST_DATA(REL),
+ DEFINE_TEST_DATA(RELA),
+ DEFINE_TEST_DATA(SHDR),
+ DEFINE_TEST_DATA(SWORD),
+ DEFINE_TEST_DATA(SXWORD),
+ DEFINE_TEST_DATA(SYM),
+ DEFINE_TEST_DATA(SYMINFO),
+ DEFINE_TEST_DATA(WORD),
+ DEFINE_TEST_DATA(XWORD),
+#endif /* TS_XLATESZ == 32 */
+ { .tsd_name = NULL }
+};
+
+
+#define NCOPIES 3
+#define NOFFSET 8 /* check every alignment in a quad word */
+
+#ifndef NO_TESTCASE_FUNCTIONS
+
+static int
+check_xlate(Elf_Data *xlator(Elf_Data *d, const Elf_Data *s, unsigned int enc),
+ int ed, Elf_Data *dst, Elf_Data *src, struct testdata *td, int ncopies)
+{
+ Elf_Data *dstret;
+ size_t msz;
+
+ msz = td->tsd_msz;
+
+ /* Invoke translator */
+ if ((dstret = xlator(dst, src, ed)) != dst) {
+ tet_printf("fail: \"%s\" " __XSTRING(TC_XLATETOM)
+ ": %s", td->tsd_name, elf_errmsg(-1));
+ tet_result(TET_FAIL);
+ return (0);
+ }
+
+ /* Check return parameters. */
+ if (dst->d_type != td->tsd_type || dst->d_size != msz*ncopies) {
+ tet_printf("fail: \"%s\" type(ret=%d,expected=%d) "
+ "size (ret=%d,expected=%d).", td->tsd_name,
+ dst->d_type, td->tsd_type, dst->d_size, msz*ncopies);
+ tet_result(TET_FAIL);
+ return (0);
+ }
+
+ return (1);
+}
+
+/*
+ * Check byte conversions:
+ */
+
+void
+__XCONCAT(tcXlate_tpByte,TS_XLATESZ)(void)
+{
+ Elf_Data dst, src;
+ int i, offset, sz;
+ char *filebuf, *membuf, *t, *ref;
+
+ ref = TYPEDEFNAME(L,QUAD);
+ sz = sizeof(TYPEDEFNAME(L,QUAD));
+
+ if ((membuf = malloc(sz*NCOPIES)) == NULL ||
+ (filebuf = malloc(sz*NCOPIES+NOFFSET)) == NULL) {
+ if (membuf)
+ free(membuf);
+ tet_infoline("unresolved: malloc() failed.");
+ tet_result(TET_UNRESOLVED);
+ return;
+ }
+
+ /*
+ * Check memory to file conversions.
+ */
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++)
+ t = memcpy(t, ref, sz) + sz;
+
+ src.d_buf = membuf;
+ src.d_size = sz*NCOPIES;
+ src.d_type = ELF_T_BYTE;
+ src.d_version = EV_CURRENT;
+
+ tet_infoline("assertion: Byte TOF() succeeds.");
+
+ for (offset = 0; offset < NOFFSET; offset++) {
+ /*
+ * LSB
+ */
+ dst.d_buf = filebuf + offset;
+ dst.d_size = sz*NCOPIES;
+ dst.d_version = EV_CURRENT;
+
+ if (TS_XLATETOF(&dst,&src,ELFDATA2LSB) != &dst ||
+ dst.d_size != sz*NCOPIES) {
+ tet_infoline("fail: LSB TOF() conversion.");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ if (memcmp(membuf, filebuf+offset, sz*NCOPIES)) {
+ tet_infoline("fail: LSB TOF() memcmp().");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ /*
+ * MSB
+ */
+ dst.d_buf = filebuf + offset;
+ dst.d_size = sz*NCOPIES;
+ dst.d_version = EV_CURRENT;
+
+ if (TS_XLATETOF(&dst,&src,ELFDATA2MSB) != &dst ||
+ dst.d_size != sz*NCOPIES) {
+ tet_infoline("fail: MSB TOF() conversion.");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ if (memcmp(membuf, filebuf+offset, sz*NCOPIES)) {
+ tet_infoline("fail: MSB TOF() memcmp().");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ }
+
+ /*
+ * Check file to memory conversions.
+ */
+
+ tet_infoline("assertion: Byte TOM() succeeds.");
+
+ ref = TYPEDEFNAME(M,QUAD);
+ sz = sizeof(TYPEDEFNAME(M,QUAD));
+
+ for (offset = 0; offset < NOFFSET; offset++) {
+
+ src.d_buf = t = filebuf + offset;
+ for (i = 0; i < NCOPIES; i++)
+ t = memcpy(t,ref,sz);
+
+ src.d_size = sz*NCOPIES;
+ src.d_type = ELF_T_BYTE;
+ src.d_version = EV_CURRENT;
+
+ /*
+ * LSB
+ */
+ dst.d_buf = membuf;
+ dst.d_size = sz*NCOPIES;
+ dst.d_version = EV_CURRENT;
+
+ if (TS_XLATETOM(&dst,&src,ELFDATA2LSB) != &dst ||
+ dst.d_size != sz * NCOPIES) {
+ tet_infoline("fail: LSB TOM() conversion.");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ if (memcmp(membuf, filebuf+offset, sz*NCOPIES)) {
+ tet_infoline("fail: LSB TOM() memcmp().");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ /*
+ * MSB
+ */
+ dst.d_buf = membuf;
+ dst.d_size = sz*NCOPIES;
+ dst.d_version = EV_CURRENT;
+
+ if (TS_XLATETOM(&dst,&src,ELFDATA2MSB) != &dst ||
+ dst.d_size != sz * NCOPIES) {
+ tet_infoline("fail: MSB TOM() conversion.");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ if (memcmp(membuf, filebuf+offset, sz*NCOPIES)) {
+ tet_infoline("fail: MSB TOM() memcmp().");
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ }
+
+ tet_result(TET_PASS);
+
+ done:
+ if (membuf)
+ free(membuf);
+ if (filebuf)
+ free(filebuf);
+}
+
+/*
+ * Check a byte conversion on a shared buffer.
+ */
+
+void
+__XCONCAT(tcXlate_tpByteShared,TS_XLATESZ)(void)
+{
+ int i;
+ size_t sz;
+ Elf_Data dst, src;
+ char *membuf, *t, *ref;
+
+#define PREPARE_SHARED(T,SZ) do { \
+ src.d_buf = dst.d_buf = membuf; \
+ src.d_size = dst.d_size = (SZ) * NCOPIES; \
+ src.d_type = dst.d_type = (T); \
+ src.d_version = dst.d_version = EV_CURRENT; \
+ } while (0)
+
+#define VERIFY(R,SZ) do { \
+ t = dst.d_buf; \
+ for (i = 0; i < NCOPIES; i++, t += (SZ)) \
+ if (memcmp((R), t, (SZ))) { \
+ tet_infoline("fail: LSB TOF() " \
+ "memcmp()."); \
+ tet_result(TET_FAIL); \
+ goto done; \
+ } \
+ } while (0)
+
+ membuf = NULL;
+ ref = TYPEDEFNAME(L,QUAD);
+ sz = sizeof(TYPEDEFNAME(L,QUAD));
+
+ if ((membuf = malloc(sz * NCOPIES)) == NULL) {
+ tet_infoline("unresolved: malloc() failed.");
+ tet_result(TET_UNRESOLVED);
+ return;
+ }
+
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++)
+ t = memcpy(t, ref, sz) + sz;
+
+ tet_infoline("assertion: byte TOF() on a shared dst/src arena "
+ "succeeds.");
+
+ PREPARE_SHARED(ELF_T_BYTE, sz);
+ if (TS_XLATETOF(&dst, &src, ELFDATA2LSB) != &dst ||
+ dst.d_size != sz * NCOPIES ||
+ dst.d_buf != src.d_buf) {
+ tet_printf("fail: LSB TOF() conversion: %s.",
+ elf_errmsg(-1));
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ VERIFY(ref,sz);
+
+ PREPARE_SHARED(ELF_T_BYTE, sz);
+ if (TS_XLATETOF(&dst, &src, ELFDATA2MSB) != &dst ||
+ dst.d_size != sz * NCOPIES ||
+ dst.d_buf != src.d_buf) {
+ tet_printf("fail: MSB TOF() conversion: %s.",
+ elf_errmsg(-1));
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ VERIFY(ref,sz);
+
+ tet_infoline("assertion: byte TOM() on a shared dst/src arena "
+ "succeeds.");
+
+ PREPARE_SHARED(ELF_T_BYTE, sz);
+ if (TS_XLATETOM(&dst, &src, ELFDATA2LSB) != &dst ||
+ dst.d_size != sz * NCOPIES ||
+ dst.d_buf != src.d_buf) {
+ tet_printf("fail: LSB TOM() conversion: %s.",
+ elf_errmsg(-1));
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ VERIFY(ref,sz);
+
+ PREPARE_SHARED(ELF_T_BYTE, sz);
+ if (TS_XLATETOM(&dst, &src, ELFDATA2MSB) != &dst ||
+ dst.d_size != sz * NCOPIES ||
+ dst.d_buf != src.d_buf) {
+ tet_printf("fail: MSB TOM() conversion: %s.",
+ elf_errmsg(-1));
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ VERIFY(ref,sz);
+
+ tet_result(TET_PASS);
+
+ done:
+ free(membuf);
+}
+
+/*
+ * Check non-byte conversions from file representations to memory.
+ */
+void
+__XCONCAT(tcXlate_tpToM,TS_XLATESZ)(void)
+{
+ Elf_Data dst, src;
+ struct testdata *td;
+ size_t fsz, msz;
+ int i, offset;
+ char *srcbuf, *membuf, *t;
+
+ srcbuf = NULL; /* file data (bytes) */
+ membuf = NULL; /* memory data (struct) */
+
+ /* Loop over all types */
+ for (td = TESTDATASET; td->tsd_name; td++) {
+
+ fsz = __XCONCAT(__XCONCAT(elf,TS_XLATESZ),_fsize)(td->tsd_type,
+ 1, EV_CURRENT);
+
+ msz = td->tsd_msz;
+
+ if (msz == 0 ||
+ fsz != td->tsd_fsz) {
+ tet_printf("? %s: msz=%d fsz=%d td->fsz=%d.",
+ td->tsd_name, msz, fsz, td->tsd_fsz);
+ }
+
+ assert(fsz == td->tsd_fsz);
+
+ /*
+ * allocate space for NCOPIES of data + offset for file data and
+ * NCOPIES of memory data.
+ */
+ if ((srcbuf = malloc(NCOPIES*fsz+NOFFSET)) == NULL ||
+ ((membuf = malloc(NCOPIES*msz))) == NULL) {
+ if (srcbuf)
+ free(srcbuf);
+ tet_infoline("unresolved: malloc() failed.");
+ tet_result(TET_UNRESOLVED);
+ return;
+ }
+
+
+ tet_printf("assertion: "__XSTRING(TS_XLATETOM)"(%s) succeeds.",
+ td->tsd_name);
+
+ for (offset = 0; offset < NOFFSET; offset++) {
+
+ src.d_buf = t = srcbuf + offset;
+ src.d_size = fsz * NCOPIES;
+ src.d_type = td->tsd_type;
+ src.d_version = EV_CURRENT;
+
+ dst.d_buf = membuf;
+ dst.d_size = msz * NCOPIES;
+ dst.d_version = EV_CURRENT;
+
+
+ /*
+ * Check conversion of LSB encoded data.
+ */
+
+ /* copy `NCOPIES*fsz' bytes in `srcbuf+offset' */
+ for (i = 0; i < NCOPIES; i++) {
+ (void) memcpy(t, td->tsd_lsb, fsz);
+ t += fsz;
+ }
+ (void) memset(membuf, 0, NCOPIES*msz);
+
+ if (check_xlate(TS_XLATETOM, ELFDATA2LSB, &dst, &src,
+ td, NCOPIES) == 0)
+ goto done;
+
+ /* compare the retrieved data with the canonical value */
+ t = dst.d_buf;
+ for (i = 0; i < NCOPIES; i++) {
+ if (memcmp(t, td->tsd_mem, msz)) {
+ tet_printf("fail: \"%s\" LSB memory "
+ "compare failed.", td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ t += msz;
+ }
+
+ /*
+ * Check conversion of MSB encoded data.
+ */
+
+ t = srcbuf + offset;
+ for (i = 0; i < NCOPIES; i++) {
+ (void) memcpy(t, td->tsd_msb, fsz);
+ t += fsz;
+ }
+ (void) memset(membuf, 0, NCOPIES*msz);
+ if (check_xlate(TS_XLATETOM, ELFDATA2MSB, &dst, &src,
+ td, NCOPIES) == 0)
+ goto done;
+
+ /* compare the retrieved data with the canonical value */
+ t = dst.d_buf;
+ for (i = 0; i < NCOPIES; i++) {
+ if (memcmp(t, td->tsd_mem, msz)) {
+ tet_printf("fail: \"%s\" MSB memory "
+ "compare failed.", td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ t += msz;
+ }
+ }
+
+ free(srcbuf); srcbuf = NULL;
+ free(membuf); membuf = NULL;
+ }
+
+ tet_result(TET_PASS);
+
+ done:
+ if (srcbuf)
+ free(srcbuf);
+ if (membuf)
+ free(membuf);
+}
+
+void
+__XCONCAT(tcXlate_tpToMShared,TS_XLATESZ)(void)
+{
+ Elf_Data dst, src;
+ struct testdata *td;
+ size_t fsz, msz;
+ int i, result;
+ char *membuf, *t;
+
+ membuf = NULL;
+
+ for (td = TESTDATASET; td->tsd_name; td++) {
+
+ tet_printf("assertion: in-place "__XSTRING(TS_XLATETOM)"(\"%s\").",
+ td->tsd_name);
+
+ fsz = __XCONCAT(__XCONCAT(elf,TS_XLATESZ),_fsize)(td->tsd_type,
+ 1, EV_CURRENT);
+ msz = td->tsd_msz;
+
+ assert(msz >= fsz);
+
+ if ((membuf = malloc(fsz * NCOPIES)) == NULL) {
+ tet_printf("unresolved: \"%s\" malloc() failed.",
+ td->tsd_name);
+ tet_result(TET_UNRESOLVED);
+ goto done;
+ }
+
+ /*
+ * In-place conversion of LSB data.
+ */
+
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++)
+ t = memcpy(t, td->tsd_lsb, fsz) + fsz;
+
+ PREPARE_SHARED(td->tsd_type, fsz);
+ result = TS_XLATETOM(&dst, &src, ELFDATA2LSB) == &dst;
+
+ if (fsz < msz) {
+ /* conversion should fail with ELF_E_DATA */
+ if (result || elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" LSB TOM() succeeded "
+ "with fsz < msz", td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ free(membuf); membuf = NULL;
+ continue;
+ }
+
+ /* conversion should have succeeded. */
+ if (!result) {
+ tet_printf("fail: \"%s\" LSB TOM() failed.",
+ td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ VERIFY(td->tsd_mem,msz);
+
+ /*
+ * In-place conversion of MSB data.
+ */
+
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++)
+ t = memcpy(t, td->tsd_msb, fsz) + fsz;
+
+ PREPARE_SHARED(td->tsd_type, fsz);
+ result = TS_XLATETOM(&dst, &src, ELFDATA2MSB) == &dst;
+
+ if (fsz < msz) {
+ /* conversion should fail with ELF_E_DATA */
+ if (result || elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" MSB TOM() succeeded "
+ "with fsz < msz", td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ free(membuf); membuf = NULL;
+ continue;
+ }
+
+ /* conversion should have succeeded. */
+ if (!result) {
+ tet_printf("fail: \"%s\" MSB TOM() failed.",
+ td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+
+ VERIFY(td->tsd_mem,msz);
+
+ }
+
+ tet_result(TET_PASS);
+
+ done:
+ if (membuf)
+ free(membuf);
+}
+
+
+/*
+ * Check non-byte conversions from memory to file.
+ */
+void
+__XCONCAT(tcXlate_tpToF,TS_XLATESZ)(void)
+{
+ Elf_Data dst, src;
+ struct testdata *td;
+ size_t fsz, msz;
+ int i, offset;
+ char *filebuf, *membuf, *t;
+
+ filebuf = NULL; /* file data (bytes) */
+ membuf = NULL; /* memory data (struct) */
+
+ /* Loop over all types */
+ for (td = TESTDATASET; td->tsd_name; td++) {
+
+ fsz = __XCONCAT(__XCONCAT(elf,TS_XLATESZ),_fsize)(td->tsd_type,
+ 1, EV_CURRENT);
+
+ msz = td->tsd_msz;
+
+ if (msz == 0 ||
+ fsz != td->tsd_fsz) {
+ tet_printf("? %s: msz=%d fsz=%d td->fsz=%d.",
+ td->tsd_name, msz, fsz, td->tsd_fsz);
+ }
+
+ assert(msz > 0);
+ assert(fsz == td->tsd_fsz);
+
+ /*
+ * allocate space for NCOPIES of data + offset for file data and
+ * NCOPIES of memory data.
+ */
+ if ((filebuf = malloc(NCOPIES*fsz+NOFFSET)) == NULL ||
+ ((membuf = malloc(NCOPIES*msz))) == NULL) {
+ if (filebuf)
+ free(filebuf);
+ tet_infoline("unresolved: malloc() failed.");
+ tet_result(TET_UNRESOLVED);
+ return;
+ }
+
+
+ tet_printf("assertion: "__XSTRING(TS_XLATETOF)"(%s) succeeds.",
+ td->tsd_name);
+
+ for (offset = 0; offset < NOFFSET; offset++) {
+
+ src.d_buf = membuf;
+ src.d_size = msz * NCOPIES;
+ src.d_type = td->tsd_type;
+ src.d_version = EV_CURRENT;
+
+ /*
+ * Check LSB conversion.
+ */
+
+ /* copy `NCOPIES' of canonical memory data to the src buffer */
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++) {
+ (void) memcpy(t, td->tsd_mem, msz);
+ t += msz;
+ }
+ (void) memset(filebuf, 0, NCOPIES*fsz+NOFFSET);
+
+ dst.d_buf = filebuf + offset;
+ dst.d_size = fsz * NCOPIES;
+ dst.d_version = EV_CURRENT;
+
+ if (check_xlate(TS_XLATETOF, ELFDATA2LSB, &dst, &src,
+ td, NCOPIES) == 0)
+ goto done;
+
+ /* compare converted data to canonical form */
+ t = filebuf + offset;
+ for (i = 0; i < NCOPIES; i++) {
+ if (memcmp(t, td->tsd_lsb, fsz)) {
+ tet_printf("fail: \"%s\" LSB memory "
+ "compare.", td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ t += fsz;
+ }
+
+ /*
+ * Check MSB conversion.
+ */
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++) {
+ (void) memcpy(t, td->tsd_mem, msz);
+ t += msz;
+ }
+ (void) memset(filebuf, 0, NCOPIES*fsz+NOFFSET);
+
+ dst.d_buf = filebuf + offset;
+ dst.d_size = fsz * NCOPIES;
+ dst.d_version = EV_CURRENT;
+
+ if (check_xlate(TS_XLATETOF, ELFDATA2MSB, &dst, &src,
+ td, NCOPIES) == 0)
+ goto done;
+
+ /* compare converted data to canonical form */
+ t = filebuf + offset;
+ for (i = 0; i < NCOPIES; i++) {
+ if (memcmp(t, td->tsd_msb, fsz)) {
+ tet_printf("fail: \"%s\" MSB memory "
+ "compare.", td->tsd_name);
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ t += fsz;
+ }
+ }
+
+ free(filebuf); filebuf = NULL;
+ free(membuf); membuf = NULL;
+ }
+
+ tet_result(TET_PASS);
+
+ done:
+ if (filebuf)
+ free(filebuf);
+ if (membuf)
+ free(membuf);
+}
+
+void
+__XCONCAT(tcXlate_tpToFShared,TS_XLATESZ)(void)
+{
+ Elf_Data dst, src;
+ struct testdata *td;
+ size_t fsz, msz;
+ int i;
+ char *membuf, *t;
+
+ membuf = NULL;
+
+ for (td = TESTDATASET; td->tsd_name; td++) {
+
+ tet_printf("assertion: in-place "__XSTRING(TS_XLATETOF)"(\"%s\").",
+ td->tsd_name);
+
+ fsz = __XCONCAT(__XCONCAT(elf,TS_XLATESZ),_fsize)(td->tsd_type,
+ 1, EV_CURRENT);
+ msz = td->tsd_msz;
+
+ assert(msz >= fsz);
+
+ if ((membuf = malloc(msz * NCOPIES)) == NULL) {
+ tet_printf("unresolved: \"%s\" malloc() failed.",
+ td->tsd_name);
+ tet_result(TET_UNRESOLVED);
+ goto done;
+ }
+
+ /*
+ * In-place conversion to LSB data.
+ */
+
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++)
+ t = memcpy(t, td->tsd_mem, msz) + msz;
+
+ PREPARE_SHARED(td->tsd_type, msz);
+ if (TS_XLATETOF(&dst, &src, ELFDATA2LSB) != &dst) {
+ tet_printf("fail: \"%s\" LSB TOF() failed: %s.",
+ td->tsd_name, elf_errmsg(-1));
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ VERIFY(td->tsd_lsb,fsz);
+
+ /*
+ * In-place conversion to MSB data.
+ */
+
+ t = membuf;
+ for (i = 0; i < NCOPIES; i++)
+ t = memcpy(t, td->tsd_mem, msz) + msz;
+
+ PREPARE_SHARED(td->tsd_type, msz);
+ if (TS_XLATETOF(&dst, &src, ELFDATA2MSB) != &dst) {
+ tet_printf("fail: \"%s\" MSB TOF() failed: %s.",
+ td->tsd_name, elf_errmsg(-1));
+ tet_result(TET_FAIL);
+ goto done;
+ }
+ VERIFY(td->tsd_msb,fsz);
+
+ }
+
+ tet_result(TET_PASS);
+
+ done:
+ if (membuf)
+ free(membuf);
+}
+
+
+
+/*
+ * Various checks for invalid arguments.
+ */
+
+void
+__XCONCAT(tcArgs_tpNullArgs,TS_XLATESZ)(void)
+{
+ Elf_Data ed;
+ int result;
+
+ tet_infoline("assertion: "__XSTRING(TS_XLATETOF) "/"
+ __XSTRING(TS_XLATETOM) " with NULL arguments fail "
+ "with ELF_E_ARGUMENT.");
+
+ result = TET_PASS;
+
+ if (TS_XLATETOF(NULL,&ed,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+
+ if (TS_XLATETOF(&ed,NULL,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(NULL,&ed,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(&ed,NULL,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+
+ tet_result(result);
+}
+
+void
+__XCONCAT(tcArgs_tpBadType,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+ char buf[1024];
+
+ tet_infoline("assertion: "__XSTRING(TS_XLATETOF) "/"
+ __XSTRING(TS_XLATETOM) " with an out of range type "
+ "fails with ELF_E_DATA.");
+
+ result = TET_PASS;
+
+ es.d_version = ed.d_version = EV_CURRENT;
+ es.d_buf = ed.d_buf = buf;
+ es.d_size = ed.d_size = sizeof(buf);
+
+ es.d_type = (Elf_Type) -1;
+
+ if (TS_XLATETOF(&ed,&es,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(&ed,&es,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ es.d_type = ELF_T_NUM;
+
+ if (TS_XLATETOF(&ed,&es,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(&ed,&es,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ tet_result(result);
+}
+
+void
+__XCONCAT(tcArgs_tpBadEncoding,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+
+ tet_infoline("assertion: "__XSTRING(TS_XLATETOF) "/"
+ __XSTRING(TS_XLATETOM) " (*,*,BADENCODING) "
+ "fails with ELF_E_ARGUMENT.");
+
+ result = TET_PASS;
+
+ if (TS_XLATETOF(&ed,&es,ELFDATANONE-1) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+ else if (TS_XLATETOF(&ed,&es,ELFDATA2MSB+1) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(&ed,&es,ELFDATANONE-1) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+ else if (TS_XLATETOM(&ed,&es,ELFDATA2MSB+1) != NULL ||
+ elf_errno() != ELF_E_ARGUMENT)
+ result = TET_FAIL;
+
+ tet_result(result);
+}
+
+void
+__XCONCAT(tcArg_tpDstSrcVersionToF,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+ char buf[sizeof(int)];
+
+ tet_infoline("assertion: "__XSTRING(TS_XLATETOF)"() / "
+ __XSTRING(TS_XLATETOM) "() with unequal "
+ "src,dst versions fails with ELF_E_UNIMPL.");
+
+ es.d_buf = ed.d_buf = buf;
+ es.d_type = ELF_T_BYTE;
+ es.d_size = ed.d_size = sizeof(buf);
+ es.d_version = EV_CURRENT;
+ ed.d_version = EV_NONE;
+
+ result = TET_PASS;
+
+ if (TS_XLATETOF(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_UNIMPL)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_UNIMPL)
+ result = TET_FAIL;
+
+ tet_result(result);
+}
+
+/*
+ * Check for an unimplemented type.
+ */
+void
+__XCONCAT(tcArg_tpUnimplemented,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int i, result;
+ char *buf;
+
+ tet_infoline("assertion: "__XSTRING(TS_XLATETOF)"() on "
+ "unimplemented types will with ELF_E_UNIMPL.");
+
+ /*
+ * allocate a buffer that is large enough for any potential
+ * ELF data structure.
+ */
+ if ((buf = malloc(1024)) == NULL) {
+ tet_infoline("unresolved: malloc() failed.");
+ tet_result(TET_UNRESOLVED);
+ return;
+ }
+
+ ed.d_buf = es.d_buf = buf;
+ ed.d_size = es.d_size = 1024;
+ ed.d_version = es.d_version = EV_CURRENT;
+
+ result = TET_PASS;
+
+ for (i = 0; i < ELF_T_NUM; i++) {
+ switch (i) {
+ case ELF_T_MOVEP:
+#if TS_XLATESZ == 32
+ case ELF_T_SXWORD:
+ case ELF_T_XWORD:
+#endif
+ break;
+ default:
+ continue;
+ }
+
+ es.d_type = i;
+
+ if (TS_XLATETOF(&ed,&es,ELFDATA2LSB) != NULL ||
+ elf_errno() != ELF_E_UNIMPL) {
+ tet_printf("fail: TOF/LSB/type=%d.", i);
+ result = TET_FAIL;
+ }
+
+ if (TS_XLATETOF(&ed,&es,ELFDATA2MSB) != NULL ||
+ elf_errno() != ELF_E_UNIMPL) {
+ tet_printf("fail: TOF/MSB/type=%d.", i);
+ result = TET_FAIL;
+ }
+
+ if (TS_XLATETOM(&ed,&es,ELFDATA2LSB) != NULL ||
+ elf_errno() != ELF_E_UNIMPL) {
+ tet_printf("fail: TOM/LSB/type=%d.", i);
+ result = TET_FAIL;
+ }
+
+ if (TS_XLATETOM(&ed,&es,ELFDATA2MSB) != NULL ||
+ elf_errno() != ELF_E_UNIMPL) {
+ tet_printf("fail: TOM/MSB/type=%d.", i);
+ result = TET_FAIL;
+ }
+ }
+
+ tet_result(result);
+ free(buf);
+}
+
+/*
+ * Check for null buffer pointers.
+ */
+void
+__XCONCAT(tcBuffer_tpNullDataPtr,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+ char buf[sizeof(int)];
+
+ tet_infoline("assertion: "__XSTRING(TS_XLATETOF)"() / "
+ __XSTRING(TS_XLATETOM) "() with a null "
+ "src,dst buffer pointer fails with ELF_E_DATA.");
+
+ result = TET_PASS;
+
+ es.d_type = ELF_T_BYTE;
+ es.d_size = ed.d_size = sizeof(buf);
+ es.d_version = EV_CURRENT;
+ ed.d_version = EV_CURRENT;
+
+ es.d_buf = NULL;
+ ed.d_buf = buf;
+ if (TS_XLATETOF(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ es.d_buf = buf;
+ ed.d_buf = NULL;
+ if (TS_XLATETOF(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ if (TS_XLATETOM(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA)
+ result = TET_FAIL;
+
+ tet_result(result);
+}
+
+/*
+ * Misaligned data.
+ */
+
+void
+__XCONCAT(tcBuffer_tpMisaligned,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+ size_t fsz, msz;
+ char *sb, *db;
+ struct testdata *td;
+
+ tet_infoline("assertion: misaligned buffers are rejected with "
+ "ELF_E_DATA.");
+
+ sb = db = NULL;
+ if ((sb = malloc(1024)) == NULL ||
+ (db = malloc(1024)) == NULL) {
+ tet_infoline("unresolved: malloc() failed.");
+ tet_result(TET_UNRESOLVED);
+ if (sb)
+ free(sb);
+ return;
+ }
+
+ result = TET_PASS;
+
+ for (td = TESTDATASET; td->tsd_name; td++) {
+ fsz = td->tsd_fsz;
+ msz = td->tsd_msz;
+
+ es.d_type = td->tsd_type;
+ es.d_version = EV_CURRENT;
+
+ /* Misalign the destination for to-memory xfers */
+ es.d_size = (1024 / fsz) * fsz; /* round down */
+ es.d_buf = sb;
+
+ ed.d_buf = db + 1; /* guaranteed to be misaliged */
+ ed.d_version = EV_CURRENT;
+ ed.d_size = 1024;
+
+ if (TS_XLATETOM(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" TOM alignment.",
+ td->tsd_name);
+ result = TET_FAIL;
+ }
+
+ /* Misalign the source for to-file xfers */
+ es.d_buf = sb + 1;
+ es.d_size = (1024/msz) * msz; /* round down */
+ ed.d_buf = db;
+
+ if (TS_XLATETOF(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" TOF alignment.",
+ td->tsd_name);
+ result = TET_FAIL;
+ }
+ }
+
+ tet_result(result);
+ free(sb);
+ free(db);
+}
+
+
+/*
+ * Overlapping buffers.
+ */
+void
+__XCONCAT(tcBuffer_tpOverlap,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+ char buf[sizeof(int)];
+
+ tet_infoline("assertion: overlapping buffers are rejected with "
+ "ELF_E_DATA.");
+
+ es.d_buf = buf; ed.d_buf = buf+1;
+ es.d_version = ed.d_version = EV_CURRENT;
+ es.d_size = ed.d_size = sizeof(buf);
+ es.d_type = ELF_T_BYTE;
+
+ result = TET_PASS;
+
+ if (TS_XLATETOF(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_infoline("fail: "__XSTRING(TS_XLATETOF));
+ result = TET_FAIL;
+ }
+
+ if (TS_XLATETOM(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_infoline("fail: "__XSTRING(TS_XLATETOM));
+ result = TET_FAIL;
+ }
+
+ tet_result(result);
+}
+
+/*
+ * Non-integral number of src elements.
+ */
+void
+__XCONCAT(tcBuffer_tpSrcExtra,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+ size_t fsz, msz;
+ char *sb, *db;
+ struct testdata *td;
+
+ tet_infoline("assertion: mis-sized buffers are rejected with "
+ "ELF_E_DATA.");
+
+ sb = db = NULL;
+ if ((sb = malloc(1024)) == NULL ||
+ (db = malloc(1024)) == NULL) {
+ tet_infoline("unresolved: malloc() failed.");
+ tet_result(TET_UNRESOLVED);
+ if (sb)
+ free(sb);
+ return;
+ }
+
+ result = TET_PASS;
+
+ for (td = TESTDATASET; td->tsd_name; td++) {
+ fsz = td->tsd_fsz;
+ msz = td->tsd_msz;
+
+ es.d_type = td->tsd_type;
+ es.d_version = EV_CURRENT;
+ ed.d_version = EV_CURRENT;
+ ed.d_buf = db;
+ es.d_buf = sb;
+ ed.d_size = 1024;
+
+ /* Pad src bytes with extra bytes for to memor */
+ es.d_size = fsz+1;
+
+ if (TS_XLATETOM(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" TOM buffer size.",
+ td->tsd_name);
+ result = TET_FAIL;
+ }
+
+ es.d_size = msz+1;
+ if (TS_XLATETOF(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" TOF buffer size.",
+ td->tsd_name);
+ result = TET_FAIL;
+ }
+ }
+
+ tet_result(result);
+ free(sb);
+ free(db);
+}
+
+void
+__XCONCAT(tcBuffer_tpDstTooSmall,TS_XLATESZ)(void)
+{
+ Elf_Data ed, es;
+ int result;
+ struct testdata *td;
+ size_t fsz, msz;
+ char buf[1024];
+
+ result = TET_PASS;
+
+ tet_infoline("assertion: too small destination buffers are rejected "
+ "with ELF_E_DATA.");
+
+ for (td = TESTDATASET; td->tsd_name; td++) {
+ msz = td->tsd_msz;
+ fsz = td->tsd_fsz;
+
+ es.d_type = td->tsd_type;
+ es.d_version = ed.d_version = EV_CURRENT;
+ es.d_buf = ed.d_buf = buf;
+
+ es.d_size = (sizeof(buf) / msz) * msz;
+ ed.d_size = 1; /* too small a size */
+
+ if (TS_XLATETOF(&ed, &es, ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" TOF dst size.",
+ td->tsd_name);
+ result = TET_FAIL;
+ }
+
+ es.d_size = (sizeof(buf) / fsz) * fsz;
+ if (TS_XLATETOM(&ed,&es,ELFDATANONE) != NULL ||
+ elf_errno() != ELF_E_DATA) {
+ tet_printf("fail: \"%s\" TOF dst size.",
+ td->tsd_name);
+ result = TET_FAIL;
+ }
+ }
+
+ tet_result(result);
+}
+
+#endif /* NO_TESTCASE_FUNCTIONS */