--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/elf4rom/libs/libelf-0.8.10/lib/64.xlatetof.c Fri Jan 15 09:07:44 2010 +0000
@@ -0,0 +1,512 @@
+/*
+ * 64.xlatetof.c - implementation of the elf64_xlateto[fm](3) functions.
+ * Copyright (C) 1995 - 2006 Michael Riepe
+ *
+ * This library 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.
+ *
+ * This library 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 this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <private.h>
+#include <ext_types.h>
+#include <byteswap.h>
+
+#if __LIBELF64
+
+#ifndef lint
+static const char rcsid[] = "@(#) $Id: 64.xlatetof.c,v 1.26 2006/07/27 22:33:40 michael Exp $";
+#endif /* lint */
+
+/*
+ * Ugly, ugly
+ */
+#ifdef _WIN32
+# define Cat2(a,b)a##b
+# define Cat3(a,b,c)a##b##c
+# define Ex1(m1,m2,a,b)m1##m2(a##b)
+# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
+#else /* _WIN32 */
+# define x
+# if defined/**/x
+# define Cat2(a,b)a##b
+# define Cat3(a,b,c)a##b##c
+# define Ex1(m1,m2,a,b)m1##m2(a##b)
+# define Ex2(m1,m2,a,b,c)m1##m2(a,b##c)
+# else
+# define Cat2(a,b)a/**/b
+# define Cat3(a,b,c)a/**/b/**/c
+# define Ex1(m1,m2,a,b)m1/**/m2(a/**/b)
+# define Ex2(m1,m2,a,b,c)m1/**/m2(a,b/**/c)
+# endif
+# undef x
+#endif /* _WIN32 */
+
+/*
+ * auxiliary macros for execution order reversal
+ */
+#define seq_forw(a,b) a b
+#define seq_back(a,b) b a
+
+/*
+ * function instantiator
+ */
+#define copy_type_e_io(name,e,io,tfrom,tto,copy) \
+ static size_t \
+ Cat3(name,_,io)(unsigned char *dst, const unsigned char *src, size_t n) { \
+ n /= sizeof(tfrom); \
+ if (n && dst) { \
+ const tfrom *from = (const tfrom*)src; \
+ tto *to = (tto*)dst; \
+ size_t i; \
+ \
+ if (sizeof(tfrom) < sizeof(tto)) { \
+ from += n; \
+ to += n; \
+ for (i = 0; i < n; i++) { \
+ --from; \
+ --to; \
+ copy(e,io,seq_back) \
+ } \
+ } \
+ else { \
+ for (i = 0; i < n; i++) { \
+ copy(e,io,seq_forw) \
+ from++; \
+ to++; \
+ } \
+ } \
+ } \
+ return n * sizeof(tto); \
+ }
+
+#define copy_type_e(name,e,type,copy) \
+ copy_type_e_io(name,e,tom,Cat2(__ext_,type),type,copy) \
+ copy_type_e_io(name,e,tof,type,Cat2(__ext_,type),copy)
+
+/*
+ * master function instantiator
+ */
+#define copy_type(name,version,type,copy) \
+ copy_type_e(Cat3(name,L,version),L,type,copy) \
+ copy_type_e(Cat3(name,M,version),M,type,copy)
+
+/*
+ * scalar copying
+ */
+#define copy_scalar_tom(type) *to = Cat2(__load_,type)(*from);
+#define copy_scalar_tof(type) Cat2(__store_,type)(*to, *from);
+
+/*
+ * structure member copying
+ */
+#define copy_tom(mb,type) to->mb = Cat2(__load_,type)(from->mb);
+#define copy_tof(mb,type) Cat2(__store_,type)(to->mb, from->mb);
+
+/*
+ * structure member copying (direction independent)
+ */
+#define copy_byte(e,io,mb) to->mb = from->mb;
+#define copy_addr(e,io,mb) Ex2(copy_,io,mb,u64,e)
+#define copy_half(e,io,mb) Ex2(copy_,io,mb,u16,e)
+#define copy_off(e,io,mb) Ex2(copy_,io,mb,u64,e)
+#define copy_sword(e,io,mb) Ex2(copy_,io,mb,i32,e)
+#define copy_word(e,io,mb) Ex2(copy_,io,mb,u32,e)
+#define copy_sxword(e,io,mb) Ex2(copy_,io,mb,i64,e)
+#define copy_xword(e,io,mb) Ex2(copy_,io,mb,u64,e)
+#define copy_arr(e,io,mb) \
+ array_copy(to->mb, sizeof(to->mb), from->mb, sizeof(from->mb));
+
+/*
+ * scalar copying (direction independent)
+ * these macros are used as `copy' arguments to copy_type()
+ */
+#define copy_addr_11(e,io,seq) Ex1(copy_scalar_,io,u64,e)
+#define copy_half_11(e,io,seq) Ex1(copy_scalar_,io,u16,e)
+#define copy_off_11(e,io,seq) Ex1(copy_scalar_,io,u64,e)
+#define copy_sword_11(e,io,seq) Ex1(copy_scalar_,io,i32,e)
+#define copy_word_11(e,io,seq) Ex1(copy_scalar_,io,u32,e)
+#define copy_sxword_11(e,io,seq)Ex1(copy_scalar_,io,i64,e)
+#define copy_xword_11(e,io,seq) Ex1(copy_scalar_,io,u64,e)
+
+/*
+ * structure copying (direction independent)
+ * these macros are used as `copy' arguments to copy_type()
+ */
+#define copy_dyn_11(e,io,seq) \
+ seq(copy_xword(e,io,d_tag), \
+ seq(copy_addr(e,io,d_un.d_ptr), \
+ nullcopy))
+#define copy_ehdr_11(e,io,seq) \
+ seq(copy_arr(e,io,e_ident), \
+ seq(copy_half(e,io,e_type), \
+ seq(copy_half(e,io,e_machine), \
+ seq(copy_word(e,io,e_version), \
+ seq(copy_addr(e,io,e_entry), \
+ seq(copy_off(e,io,e_phoff), \
+ seq(copy_off(e,io,e_shoff), \
+ seq(copy_word(e,io,e_flags), \
+ seq(copy_half(e,io,e_ehsize), \
+ seq(copy_half(e,io,e_phentsize), \
+ seq(copy_half(e,io,e_phnum), \
+ seq(copy_half(e,io,e_shentsize), \
+ seq(copy_half(e,io,e_shnum), \
+ seq(copy_half(e,io,e_shstrndx), \
+ nullcopy))))))))))))))
+#define copy_phdr_11(e,io,seq) \
+ seq(copy_word(e,io,p_type), \
+ seq(copy_word(e,io,p_flags), \
+ seq(copy_off(e,io,p_offset), \
+ seq(copy_addr(e,io,p_vaddr), \
+ seq(copy_addr(e,io,p_paddr), \
+ seq(copy_xword(e,io,p_filesz), \
+ seq(copy_xword(e,io,p_memsz), \
+ seq(copy_xword(e,io,p_align), \
+ nullcopy))))))))
+#if __LIBELF64_IRIX
+#define copy_rela_11(e,io,seq) \
+ seq(copy_addr(e,io,r_offset), \
+ seq(copy_word(e,io,r_sym), \
+ seq(copy_byte(e,io,r_ssym), \
+ seq(copy_byte(e,io,r_type3), \
+ seq(copy_byte(e,io,r_type2), \
+ seq(copy_byte(e,io,r_type), \
+ seq(copy_sxword(e,io,r_addend), \
+ nullcopy)))))))
+#define copy_rel_11(e,io,seq) \
+ seq(copy_addr(e,io,r_offset), \
+ seq(copy_word(e,io,r_sym), \
+ seq(copy_byte(e,io,r_ssym), \
+ seq(copy_byte(e,io,r_type3), \
+ seq(copy_byte(e,io,r_type2), \
+ seq(copy_byte(e,io,r_type), \
+ nullcopy))))))
+#else /* __LIBELF64_IRIX */
+#define copy_rela_11(e,io,seq) \
+ seq(copy_addr(e,io,r_offset), \
+ seq(copy_xword(e,io,r_info), \
+ seq(copy_sxword(e,io,r_addend), \
+ nullcopy)))
+#define copy_rel_11(e,io,seq) \
+ seq(copy_addr(e,io,r_offset), \
+ seq(copy_xword(e,io,r_info), \
+ nullcopy))
+#endif /* __LIBELF64_IRIX */
+#define copy_shdr_11(e,io,seq) \
+ seq(copy_word(e,io,sh_name), \
+ seq(copy_word(e,io,sh_type), \
+ seq(copy_xword(e,io,sh_flags), \
+ seq(copy_addr(e,io,sh_addr), \
+ seq(copy_off(e,io,sh_offset), \
+ seq(copy_xword(e,io,sh_size), \
+ seq(copy_word(e,io,sh_link), \
+ seq(copy_word(e,io,sh_info), \
+ seq(copy_xword(e,io,sh_addralign), \
+ seq(copy_xword(e,io,sh_entsize), \
+ nullcopy))))))))))
+#define copy_sym_11(e,io,seq) \
+ seq(copy_word(e,io,st_name), \
+ seq(copy_byte(e,io,st_info), \
+ seq(copy_byte(e,io,st_other), \
+ seq(copy_half(e,io,st_shndx), \
+ seq(copy_addr(e,io,st_value), \
+ seq(copy_xword(e,io,st_size), \
+ nullcopy))))))
+
+#define nullcopy /**/
+
+static size_t
+byte_copy(unsigned char *dst, const unsigned char *src, size_t n) {
+ if (n && dst && dst != src) {
+#if HAVE_BROKEN_MEMMOVE
+ size_t i;
+
+ if (dst >= src + n || dst + n <= src) {
+ memcpy(dst, src, n);
+ }
+ else if (dst < src) {
+ for (i = 0; i < n; i++) {
+ dst[i] = src[i];
+ }
+ }
+ else {
+ for (i = n; --i; ) {
+ dst[i] = src[i];
+ }
+ }
+#else /* HAVE_BROKEN_MEMMOVE */
+ memmove(dst, src, n);
+#endif /* HAVE_BROKEN_MEMMOVE */
+ }
+ return n;
+}
+
+static void
+array_copy(unsigned char *dst, size_t dlen, const unsigned char *src, size_t slen) {
+ byte_copy(dst, src, dlen < slen ? dlen : slen);
+ if (dlen > slen) {
+ memset(dst + slen, 0, dlen - slen);
+ }
+}
+
+/*
+ * instantiate copy functions
+ */
+copy_type(addr_64,_,Elf64_Addr,copy_addr_11)
+copy_type(half_64,_,Elf64_Half,copy_half_11)
+copy_type(off_64,_,Elf64_Off,copy_off_11)
+copy_type(sword_64,_,Elf64_Sword,copy_sword_11)
+copy_type(word_64,_,Elf64_Word,copy_word_11)
+copy_type(sxword_64,_,Elf64_Sxword,copy_sxword_11)
+copy_type(xword_64,_,Elf64_Xword,copy_xword_11)
+copy_type(dyn_64,11,Elf64_Dyn,copy_dyn_11)
+copy_type(ehdr_64,11,Elf64_Ehdr,copy_ehdr_11)
+copy_type(phdr_64,11,Elf64_Phdr,copy_phdr_11)
+copy_type(rela_64,11,Elf64_Rela,copy_rela_11)
+copy_type(rel_64,11,Elf64_Rel,copy_rel_11)
+copy_type(shdr_64,11,Elf64_Shdr,copy_shdr_11)
+copy_type(sym_64,11,Elf64_Sym,copy_sym_11)
+
+typedef size_t (*xlator)(unsigned char*, const unsigned char*, size_t);
+typedef xlator xltab[ELF_T_NUM][2];
+
+/*
+ * translation table (64-bit, version 1 -> version 1)
+ */
+#if PIC
+static xltab
+#else /* PIC */
+static const xltab
+#endif /* PIC */
+xlate64_11[/*encoding*/] = {
+ {
+ { byte_copy, byte_copy },
+ { addr_64L__tom, addr_64L__tof },
+ { dyn_64L11_tom, dyn_64L11_tof },
+ { ehdr_64L11_tom, ehdr_64L11_tof },
+ { half_64L__tom, half_64L__tof },
+ { off_64L__tom, off_64L__tof },
+ { phdr_64L11_tom, phdr_64L11_tof },
+ { rela_64L11_tom, rela_64L11_tof },
+ { rel_64L11_tom, rel_64L11_tof },
+ { shdr_64L11_tom, shdr_64L11_tof },
+ { sword_64L__tom, sword_64L__tof },
+ { sym_64L11_tom, sym_64L11_tof },
+ { word_64L__tom, word_64L__tof },
+ { sxword_64L__tom, sxword_64L__tof },
+ { xword_64L__tom, xword_64L__tof },
+#if __LIBELF_SYMBOL_VERSIONS
+ { _elf_verdef_64L11_tom, _elf_verdef_64L11_tof },
+ { _elf_verneed_64L11_tom, _elf_verneed_64L11_tof },
+#else /* __LIBELF_SYMBOL_VERSIONS */
+ { 0, 0 },
+ { 0, 0 },
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+ },
+ {
+ { byte_copy, byte_copy },
+ { addr_64M__tom, addr_64M__tof },
+ { dyn_64M11_tom, dyn_64M11_tof },
+ { ehdr_64M11_tom, ehdr_64M11_tof },
+ { half_64M__tom, half_64M__tof },
+ { off_64M__tom, off_64M__tof },
+ { phdr_64M11_tom, phdr_64M11_tof },
+ { rela_64M11_tom, rela_64M11_tof },
+ { rel_64M11_tom, rel_64M11_tof },
+ { shdr_64M11_tom, shdr_64M11_tof },
+ { sword_64M__tom, sword_64M__tof },
+ { sym_64M11_tom, sym_64M11_tof },
+ { word_64M__tom, word_64M__tof },
+ { sxword_64M__tom, sxword_64M__tof },
+ { xword_64M__tom, xword_64M__tof },
+#if __LIBELF_SYMBOL_VERSIONS
+ { _elf_verdef_64M11_tom, _elf_verdef_64M11_tof },
+ { _elf_verneed_64M11_tom, _elf_verneed_64M11_tof },
+#else /* __LIBELF_SYMBOL_VERSIONS */
+ { 0, 0 },
+ { 0, 0 },
+#endif /* __LIBELF_SYMBOL_VERSIONS */
+ },
+};
+
+/*
+ * main translation table (64-bit)
+ */
+#if PIC
+static xltab*
+#else /* PIC */
+static const xltab *const
+#endif /* PIC */
+xlate64[EV_CURRENT - EV_NONE][EV_CURRENT - EV_NONE] = {
+ { xlate64_11, },
+};
+
+#define translator(sv,dv,enc,type,d) \
+ (xlate64[(sv) - EV_NONE - 1] \
+ [(dv) - EV_NONE - 1] \
+ [(enc) - ELFDATA2LSB] \
+ [(type) - ELF_T_BYTE] \
+ [d])
+
+/*
+ * destination buffer size
+ */
+size_t
+_elf64_xltsize(const Elf_Data *src, unsigned dv, unsigned encode, int tof) {
+ Elf_Type type = src->d_type;
+ unsigned sv = src->d_version;
+ xlator op;
+
+ if (!valid_version(sv) || !valid_version(dv)) {
+ seterr(ERROR_UNKNOWN_VERSION);
+ return (size_t)-1;
+ }
+ if (tof) {
+ /*
+ * Encoding doesn't really matter (the translator only looks at
+ * the source, which resides in memory), but we need a proper
+ * encoding to select a translator...
+ */
+ encode = ELFDATA2LSB;
+ }
+ else if (!valid_encoding(encode)) {
+ seterr(ERROR_UNKNOWN_ENCODING);
+ return (size_t)-1;
+ }
+ if (!valid_type(type)) {
+ seterr(ERROR_UNKNOWN_TYPE);
+ return (size_t)-1;
+ }
+ if (!(op = translator(sv, dv, encode, type, tof))) {
+ seterr(ERROR_UNKNOWN_TYPE);
+ return (size_t)-1;
+ }
+ return (*op)(NULL, src->d_buf, src->d_size);
+}
+
+/*
+ * direction-independent translation
+ */
+static Elf_Data*
+elf64_xlate(Elf_Data *dst, const Elf_Data *src, unsigned encode, int tof) {
+ Elf_Type type;
+ int dv;
+ int sv;
+ size_t dsize;
+ size_t tmp;
+ xlator op;
+
+ if (!src || !dst) {
+ return NULL;
+ }
+ if (!src->d_buf || !dst->d_buf) {
+ seterr(ERROR_NULLBUF);
+ return NULL;
+ }
+ if (!valid_encoding(encode)) {
+ seterr(ERROR_UNKNOWN_ENCODING);
+ return NULL;
+ }
+ sv = src->d_version;
+ dv = dst->d_version;
+ if (!valid_version(sv) || !valid_version(dv)) {
+ seterr(ERROR_UNKNOWN_VERSION);
+ return NULL;
+ }
+ type = src->d_type;
+ if (!valid_type(type)) {
+ seterr(ERROR_UNKNOWN_TYPE);
+ return NULL;
+ }
+ op = translator(sv, dv, encode, type, tof);
+ if (!op) {
+ seterr(ERROR_UNKNOWN_TYPE);
+ return NULL;
+ }
+ dsize = (*op)(NULL, src->d_buf, src->d_size);
+ if (dsize == (size_t)-1) {
+ return NULL;
+ }
+ if (dst->d_size < dsize) {
+ seterr(ERROR_DST2SMALL);
+ return NULL;
+ }
+ if (dsize) {
+ tmp = (*op)(dst->d_buf, src->d_buf, src->d_size);
+ if (tmp == (size_t)-1) {
+ return NULL;
+ }
+ elf_assert(tmp == dsize);
+ }
+ dst->d_size = dsize;
+ dst->d_type = type;
+ return dst;
+}
+
+/*
+ * finally, the "official" translation functions
+ */
+Elf_Data*
+elf64_xlatetom(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+ return elf64_xlate(dst, src, encode, 0);
+}
+
+Elf_Data*
+elf64_xlatetof(Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+ return elf64_xlate(dst, src, encode, 1);
+}
+
+Elf_Data*
+gelf_xlatetom(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+ if (elf) {
+ if (elf->e_kind != ELF_K_ELF) {
+ seterr(ERROR_NOTELF);
+ }
+ else if (elf->e_class == ELFCLASS32) {
+ return elf32_xlatetom(dst, src, encode);
+ }
+ else if (elf->e_class == ELFCLASS64) {
+ return elf64_xlatetom(dst, src, encode);
+ }
+ else if (valid_class(elf->e_class)) {
+ seterr(ERROR_UNIMPLEMENTED);
+ }
+ else {
+ seterr(ERROR_UNKNOWN_CLASS);
+ }
+ }
+ return NULL;
+}
+
+Elf_Data*
+gelf_xlatetof(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) {
+ if (elf) {
+ if (elf->e_kind != ELF_K_ELF) {
+ seterr(ERROR_NOTELF);
+ }
+ else if (elf->e_class == ELFCLASS32) {
+ return elf32_xlatetof(dst, src, encode);
+ }
+ else if (elf->e_class == ELFCLASS64) {
+ return elf64_xlatetof(dst, src, encode);
+ }
+ else if (valid_class(elf->e_class)) {
+ seterr(ERROR_UNIMPLEMENTED);
+ }
+ else {
+ seterr(ERROR_UNKNOWN_CLASS);
+ }
+ }
+ return NULL;
+}
+
+#endif /* __LIBELF64__ */