--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tools/elf4rom/libs/libelf-0.8.10/lib/verneed.h Fri Jan 15 09:07:44 2010 +0000
@@ -0,0 +1,245 @@
+/*
+ * verneed.h - copy versioning information.
+ * Copyright (C) 2001 - 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
+ */
+
+#ifndef lint
+static const char verneed_h_rcsid[] = "@(#) $Id: verneed.h,v 1.12 2006/07/27 22:40:03 michael Exp $";
+#endif /* lint */
+
+#if VER_NEED_CURRENT != 1
+#error libelf currently does not support VER_NEED_CURRENT != 1
+#endif /* VER_NEED_CURRENT != 1 */
+
+#if TOFILE
+
+static void
+__store_vernaux(vernaux_ftype *dst, const vernaux_mtype *src, unsigned enc) {
+ if (enc == ELFDATA2LSB) {
+ __store_u32L(dst->vna_hash, src->vna_hash);
+ __store_u16L(dst->vna_flags, src->vna_flags);
+ __store_u16L(dst->vna_other, src->vna_other);
+ __store_u32L(dst->vna_name, src->vna_name);
+ __store_u32L(dst->vna_next, src->vna_next);
+ }
+ else {
+ __store_u32M(dst->vna_hash, src->vna_hash);
+ __store_u16M(dst->vna_flags, src->vna_flags);
+ __store_u16M(dst->vna_other, src->vna_other);
+ __store_u32M(dst->vna_name, src->vna_name);
+ __store_u32M(dst->vna_next, src->vna_next);
+ }
+}
+
+static void
+__store_verneed(verneed_ftype *dst, const verneed_mtype *src, unsigned enc) {
+ if (enc == ELFDATA2LSB) {
+ __store_u16L(dst->vn_version, src->vn_version);
+ __store_u16L(dst->vn_cnt, src->vn_cnt);
+ __store_u32L(dst->vn_file, src->vn_file);
+ __store_u32L(dst->vn_aux, src->vn_aux);
+ __store_u32L(dst->vn_next, src->vn_next);
+ }
+ else {
+ __store_u16M(dst->vn_version, src->vn_version);
+ __store_u16M(dst->vn_cnt, src->vn_cnt);
+ __store_u32M(dst->vn_file, src->vn_file);
+ __store_u32M(dst->vn_aux, src->vn_aux);
+ __store_u32M(dst->vn_next, src->vn_next);
+ }
+}
+
+typedef vernaux_mtype vernaux_stype;
+typedef vernaux_ftype vernaux_dtype;
+typedef verneed_mtype verneed_stype;
+typedef verneed_ftype verneed_dtype;
+typedef align_mtype verneed_atype;
+
+#define copy_vernaux_srctotmp(d, s, e) (*(d) = *(s))
+#define copy_vernaux_tmptodst(d, s, e) __store_vernaux((d), (s), (e))
+#define copy_verneed_srctotmp(d, s, e) (*(d) = *(s))
+#define copy_verneed_tmptodst(d, s, e) __store_verneed((d), (s), (e))
+
+#define translator_suffix _tof
+
+#else /* TOFILE */
+
+static void
+__load_vernaux(vernaux_mtype *dst, const vernaux_ftype *src, unsigned enc) {
+ if (enc == ELFDATA2LSB) {
+ dst->vna_hash = __load_u32L(src->vna_hash);
+ dst->vna_flags = __load_u16L(src->vna_flags);
+ dst->vna_other = __load_u16L(src->vna_other);
+ dst->vna_name = __load_u32L(src->vna_name);
+ dst->vna_next = __load_u32L(src->vna_next);
+ }
+ else {
+ dst->vna_hash = __load_u32M(src->vna_hash);
+ dst->vna_flags = __load_u16M(src->vna_flags);
+ dst->vna_other = __load_u16M(src->vna_other);
+ dst->vna_name = __load_u32M(src->vna_name);
+ dst->vna_next = __load_u32M(src->vna_next);
+ }
+}
+
+static void
+__load_verneed(verneed_mtype *dst, const verneed_ftype *src, unsigned enc) {
+ if (enc == ELFDATA2LSB) {
+ dst->vn_version = __load_u16L(src->vn_version);
+ dst->vn_cnt = __load_u16L(src->vn_cnt);
+ dst->vn_file = __load_u32L(src->vn_file);
+ dst->vn_aux = __load_u32L(src->vn_aux);
+ dst->vn_next = __load_u32L(src->vn_next);
+ }
+ else {
+ dst->vn_version = __load_u16M(src->vn_version);
+ dst->vn_cnt = __load_u16M(src->vn_cnt);
+ dst->vn_file = __load_u32M(src->vn_file);
+ dst->vn_aux = __load_u32M(src->vn_aux);
+ dst->vn_next = __load_u32M(src->vn_next);
+ }
+}
+
+typedef vernaux_ftype vernaux_stype;
+typedef vernaux_mtype vernaux_dtype;
+typedef verneed_ftype verneed_stype;
+typedef verneed_mtype verneed_dtype;
+typedef align_ftype verneed_atype;
+
+#define copy_vernaux_srctotmp(d, s, e) __load_vernaux((d), (s), (e))
+#define copy_vernaux_tmptodst(d, s, e) (*(d) = *(s))
+#define copy_verneed_srctotmp(d, s, e) __load_verneed((d), (s), (e))
+#define copy_verneed_tmptodst(d, s, e) (*(d) = *(s))
+
+#define translator_suffix _tom
+
+#endif /* TOFILE */
+
+#define cat3(a,b,c) a##b##c
+#define xlt3(p,e,s) cat3(p,e,s)
+#define xltprefix(x) xlt3(x,_,class_suffix)
+#define translator(x,e) xlt3(xltprefix(_elf_##x),e,translator_suffix)
+
+static size_t
+xlt_verneed(unsigned char *dst, const unsigned char *src, size_t n, unsigned enc) {
+ size_t off;
+
+ if (sizeof(verneed_stype) != sizeof(verneed_dtype)
+ || sizeof(vernaux_stype) != sizeof(vernaux_dtype)) {
+ /* never happens for ELF v1 and Verneed v1 */
+ seterr(ERROR_UNIMPLEMENTED);
+ return (size_t)-1;
+ }
+ /* size translation shortcut */
+ if (dst == NULL) {
+ return n;
+ }
+ if (src == NULL) {
+ seterr(ERROR_NULLBUF);
+ return (size_t)-1;
+ }
+ off = 0;
+ while (off + sizeof(verneed_stype) <= n) {
+ const verneed_stype *svn;
+ verneed_dtype *dvn;
+ verneed_mtype vn;
+ size_t acount;
+ size_t aoff;
+
+ /*
+ * check for proper alignment
+ */
+ if (off % sizeof(verneed_atype)) {
+ seterr(ERROR_VERNEED_FORMAT);
+ return (size_t)-1;
+ }
+ /*
+ * copy and check src
+ */
+ svn = (verneed_stype*)(src + off);
+ dvn = (verneed_dtype*)(dst + off);
+ copy_verneed_srctotmp(&vn, svn, enc);
+ if (vn.vn_version < 1
+ || vn.vn_version > VER_NEED_CURRENT) {
+ seterr(ERROR_VERNEED_VERSION);
+ return (size_t)-1;
+ }
+ if (vn.vn_cnt < 1
+ || vn.vn_aux == 0) {
+ seterr(ERROR_VERNEED_FORMAT);
+ return (size_t)-1;
+ }
+ copy_verneed_tmptodst(dvn, &vn, enc);
+ /*
+ * copy aux array
+ */
+ aoff = off + vn.vn_aux;
+ for (acount = 0; acount < vn.vn_cnt; acount++) {
+ const vernaux_stype *svna;
+ vernaux_dtype *dvna;
+ vernaux_mtype vna;
+
+ /*
+ * are we still inside the buffer limits?
+ */
+ if (aoff + sizeof(vernaux_stype) > n) {
+ break;
+ }
+ /*
+ * check for proper alignment
+ */
+ if (aoff % sizeof(verneed_atype)) {
+ seterr(ERROR_VERNEED_FORMAT);
+ return (size_t)-1;
+ }
+ /*
+ * copy and check src
+ */
+ svna = (vernaux_stype*)(src + aoff);
+ dvna = (vernaux_dtype*)(dst + aoff);
+ copy_vernaux_srctotmp(&vna, svna, enc);
+ copy_vernaux_tmptodst(dvna, &vna, enc);
+ /*
+ * advance to next vernaux
+ */
+ if (vna.vna_next == 0) {
+ /* end of list */
+ break;
+ }
+ aoff += vna.vna_next;
+ }
+ /*
+ * advance to next verneed
+ */
+ if (vn.vn_next == 0) {
+ /* end of list */
+ break;
+ }
+ off += vn.vn_next;
+ }
+ return n;
+}
+
+size_t
+translator(verneed,L11)(unsigned char *dst, const unsigned char *src, size_t n) {
+ return xlt_verneed(dst, src, n, ELFDATA2LSB);
+}
+
+size_t
+translator(verneed,M11)(unsigned char *dst, const unsigned char *src, size_t n) {
+ return xlt_verneed(dst, src, n, ELFDATA2MSB);
+}