#!@@CT_bash@@

 # NON-CONFIGURABLE STUFF!

 export LC_ALL=C

 version="@@CT_VERSION@@"

 bits="@@CT_BITS@@"

 sed="@@CT_sed@@"

 grep="@@CT_grep@@"

 my_name="$( basename "${0}" )"

 prefix="${0%-ldd}"

 gcc="${prefix}-gcc"

 readelf="${prefix}-readelf"

 fake_load_addr="$((0xdeadbeef))"

 fake_load_addr_sys="$((0x8badf00d))"

 ld_library_path="/lib:/usr/lib"

 do_error() {

     printf "%s: %s\n" "${my_name}" "$*" >&2

 }

 do_opt_error() {

     do_error "$@"

     printf "Try \`%s --help' for more information\n" >&2

 }

 do_trace() {

     local depth=0

     [ -z "${CT_XLDD_VERBOSE}" ] && return 0

     for((depth=0; "${#FUNCNAME[$((depth+1))]}" != 0; depth++)); do :; done

     printf "%*s" $((4*(depth-1))) "" >&2

     printf -- "$@" >&2

 }

 show_version() {

     # Fake a real ldd, just in case some dumb script would check

     cat <<_EOF_

 ldd (crosstool-NG) ${version}

 Copyright (C) 2010 "Yann E. MORIN" <yann.morin.1998@anciens.enib.fr>

 This is free software; see the source for copying conditions.  There is NO

 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 Licensed under the GPLv2, see the file LICENSES in the top-directory of the

 sources for this package.

 _EOF_

 }

 show_help() {

     cat <<_EOF_

 Usage: ${my_name} [OPTION]... --root DIR FILE...

       --help              print this help and exit

       --version           print version information and exit

       --root dir          treat dir as being the root of the target

   -s, --show-system       mark libs from the sysroot with a trailing '[*]'

 _EOF_

     cat <<_EOF_ |fmt

 ${my_name} tries to mimick the behavior of a real native ldd, but can be

 used in a cross-development environment. Here is how it differs from a

 real native ldd:

 If the CT_XLDD_DEBUG variable is set and non-empty, then ${myname} will

 print a lot of debug messages, explaining how it builds the library

 search path, and how each library was found and why.

 The LD_LIBRARY_PATH variable is not used, as it can not reliably be

 guessed except at runtime, and we can't run.

 ${my_name} does not scan /etc/ld.so.cache, but instead uses /etc/ld.so.conf

 (it understands the include directives therein for libces that have that).

 ${my_name} will search the directory specified with --root for libraries

 to resolve the NEEDED tags. If --root is not set, then ${my_name} will

 use the value in the environment variable \${CT_XLDD_ROOT}. If neither

 is set, then this is an error.

 If NEEDED libraries can't be found in the specified root directory, then

 ${my_name} will also look in the sysroot of the toolchain to see if it

 can find them.

 For NEEDED libraries that were found, the output will look like:

         libneeded.so => /path/to/libneeded.so (0xloadaddr)

 and for those that were not found, the output will look like:

         libneeded.so not found

 The paths are relative to the specified root directory, or to the sysroot

 (eg. /lib/libneeded.so, /usr/lib/libneeded.so, and so on...).

 The expected load address 'loadaddr' is a faked address to match the output

 of the real ldd, but has no actual meaning (set to some constants for now,

 0x8badf00d for libraries from the sysroot, 0xdeadbeef for others).

 _EOF_

 # Unimplemeted yet:

 #  -d, --data-relocs       process data relocations

 #  -r, --function-relocs   process data and function relocations

 #  -u, --unused            print unused direct dependencies

 #  -v, --verbose           print all information

 # See also this thread:

 #  http://sourceware.org/ml/crossgcc/2008-09/msg00057.html

 }

 # Parse command line options

 root="${CT_XLDD_ROOT}"

 show_system=

 while true; do

     case "${1}" in

         --help)

             show_help

             exit 0

             ;;

         --version)

             show_version

             exit 0

             ;;

         --root)

             root="$2"

             shift

             ;;

         --root=*)

             root="${1#--root=}"

             ;;

         --show-system|-s)

             show_system=1

             ;;

         -*)

             do_opt_error "unrecognized option \`${1}'"

             exit 1

             ;;

         *)

             break

             ;;

     esac

     shift

 done

 # Sanity checks

 if [ -z "${root}" ]; then

     do_opt_error "no root given"

     exit 1

 fi

 if [ ! -d "${root}" ]; then

     do_error "\`${root}': no such file or directory"

     exit 1

 fi

 sysroot="$( "${gcc}" -print-sysroot 2>/dev/null )"

 if [ -z "${sysroot}" ]; then

     sysroot="$( "${gcc}" -print-file-name=libc.so 2>/dev/null   \

                 |sed -r -e 's:/usr/lib/libc.so$::;'             \

               )"

 fi

 if [ -z "${sysroot}" ]; then

     do_error "unable to find sysroot for \`${gcc}'"

 fi

 do_report_needed_found() {

     local needed="${1}"

     local path="${2}"

     local system="${3}"

     local loadaddr

     local sys

     if [ -z "${system}" ]; then

         loadaddr="${fake_load_addr}"

     else

         loadaddr="${fake_load_addr_sys}"

         if [ -n "${show_system}" ]; then

             sys=" [*]"

         fi

     fi

     printf "%8s%s => %s (0x%0*x)%s\n"   \

            ""                           \

            "${needed}"                  \

            "${path}"                    \

            "$((bits/4))"                \

            "${loadaddr}"                \

            "${sys}"

 }

 # Search a needed file, scanning ${lib_dir} in the root directory

 do_find_needed() {

     local needed="${1}"

     local found

     local found_sysroot

     local d

     do_trace "Searching for '${needed}'\n"

     for d in "${needed_search_path[@]}"; do

         do_trace "-> looking in '${d}'\n"

         if [ -f "${root}${d}/${needed}" ]; then

             found="${d}/${needed}"

             do_trace "---> found\n"

             break

         fi

     done

     if [ -z "${found}" ]; then

     for d in "${needed_search_path[@]}"; do

         do_trace "-> looking in '${d}' (sysroot)\n"

         if [ -f "${sysroot}${d}/${needed}" ]; then

             found_sysroot="${d}/${needed}"

             do_trace "---> found\n"

             break

         fi

     done

     fi

     if [ -n "${found}" ]; then

         do_report_needed_found "${needed}" "${found}"

         do_process_file "${root}${found}"

     elif [ -n "${found_sysroot}" ]; then

         do_report_needed_found "${needed}" "${found_sysroot}" "sys"

         do_process_file "${sysroot}${found_sysroot}"

     else

         printf "%8c%s not found\n" "" "${needed}"

     fi

 }

 # Scan a file for all NEEDED tags

 do_process_file() {

     local file="${1}"

     local n m

     local found

     do_trace "Parsing file '${file}'\n"

     for n in $( "${readelf}" -d "${file}"                                           \

                 |"${grep}" -E '\(NEEDED\)'                                          \

                 |"${sed}" -r -e 's/^.*Shared library:[[:space:]]+\[(.*)\]$/\1/;'    \

               ); do

         found=0

         for m in "${needed_list[@]}"; do

             [ "${n}" = "${m}" ] && found=1 && break

         done

         if [ ${found} -ne 0 ]; then

             do_trace "-> skipping already known dependency '${n}'\n"

             continue

         fi

         do_trace "-> handling new dependency '${n}'\n"

         needed_list+=( "${n}" )

         do_find_needed "${n}"

      done

 }

 # Recursively scan a /etc/ld.so.conf file

 do_scan_etc_ldsoconf() {

     local ldsoconf="${1}"

     local g

     local f

     [ -f "${ldsoconf}" ] || return 0

     do_trace "Parsing ld.so.conf: '${ldsoconf}'\n"

     while read line; do

         case "${line}" in

             include\ *)

                 g="${root}${line#include }"

                 do_trace "-> handling include directive '${g}'\n"

                 for f in ${g}; do

                     do_scan_etc_ldsoconf "${f}"

                 done

                 ;;

             \#*|"")

                 ;;

             *)

                 do_trace "-> adding search dir '${line}'\n"

                 needed_search_path+=( "${line}" )

                 ;;

         esac

     done <"${ldsoconf}"

 }

 # Build up the full list of search directories

 declare -a needed_search_path

 do_trace "Adding basic lib dirs\n"

 ld_library_path="${ld_library_path}:"

 while [ -n "${ld_library_path}" ]; do

     d="${ld_library_path%%:*}"

     if [ -n "${d}" ]; then

         do_trace "-> adding search dir '${d}'\n"

         needed_search_path+=( "${d}" )

     fi

     ld_library_path="${ld_library_path#*:}"

 done

 do_trace "Scanning '/etc/ld.so.conf'\n"

 do_scan_etc_ldsoconf "${root}/etc/ld.so.conf"

 do_trace "Search path:\n"

 for p in "${needed_search_path[@]}"; do

     do_trace "-> '${p}'\n"

 done

 do_trace "Scanning file '${1}'\n"

 declare -a needed_list

 do_process_file "${1}"