#!@@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

 }

 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:

 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).

 [Note: this is missing for now...]

 ${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

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

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

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

             break

         fi

     done

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

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

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

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

             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}"

     "${readelf}" -d "${file}"                                           \

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

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

     |while read needed; do

         do_find_needed "${needed}"

      done

 }

 # Build up the full list of search directories

 declare -a needed_search_path

 ld_library_path="${ld_library_path}:"

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

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

     [ -n "${d}" ] && needed_search_path+=( "${d}" )

     ld_library_path="${ld_library_path#*:}"

 done

 do_process_file "${1}"