[Libgomp,Fortran] Fix canadian cross build

Message ID CAD57uCd01sx_Swz7Xs=fjKde+2sFRTWA6SqbZLdC+SuYWw=Z0w@mail.gmail.com
State New
Headers show

Commit Message

Yvan Roux June 23, 2017, 1:44 p.m.
Hello,

Fortran parts of libgomp (omp_lib.mod, openacc.mod, etc...) are
missing in a canadian cross build, at least when target gfortran
compiler comes from PATH and not from GFORTRAN_FOR_TARGET.

Back in 2010, executability test of GFORTRAN was added to fix libgomp
build on cygwin, but when the executable doesn't contain the path,
"test -x" fails and part of the library are not built.

This patch fixes the issue by using M4 macro AC_PATH_PROG (which
returns the absolute name) instead of AC_CHECK_PROG in the function
defined in config/acx.m4: NCN_STRICT_CHECK_TARGET_TOOLS.  I renamed it
into NCN_STRICT_PATH_TARGET_TOOLS to keep the semantic used in M4.

Tested by building cross and candian cross toolchain (host:
i686-w64-mingw32) for arm-linux-gnueabihf with issue and with a
complete libgomp.

ok for trunk ?

Thanks
Yvan

config/ChangeLog
2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

        * acx.m4 (NCN_STRICT_CHECK_TARGET_TOOLS): Renamed to ...
        (NCN_STRICT_PATH_TARGET_TOOLS): ... this.  It reflects the replacement
        of AC_CHECK_PROG by AC_PATH_PROG to get the absolute name of the
        program.
        (ACX_CHECK_INSTALLED_TARGET_TOOL): Use renamed function.

ChangeLog
2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

        * configure.ac: Use NCN_STRICT_PATH_TARGET_TOOLS instead of
        NCN_STRICT_CHECK_TARGET_TOOLS.
        * configure: Regenerate.

Comments

Yvan Roux July 3, 2017, 9:21 a.m. | #1
On 23 June 2017 at 15:44, Yvan Roux <yvan.roux@linaro.org> wrote:
> Hello,

>

> Fortran parts of libgomp (omp_lib.mod, openacc.mod, etc...) are

> missing in a canadian cross build, at least when target gfortran

> compiler comes from PATH and not from GFORTRAN_FOR_TARGET.

>

> Back in 2010, executability test of GFORTRAN was added to fix libgomp

> build on cygwin, but when the executable doesn't contain the path,

> "test -x" fails and part of the library are not built.

>

> This patch fixes the issue by using M4 macro AC_PATH_PROG (which

> returns the absolute name) instead of AC_CHECK_PROG in the function

> defined in config/acx.m4: NCN_STRICT_CHECK_TARGET_TOOLS.  I renamed it

> into NCN_STRICT_PATH_TARGET_TOOLS to keep the semantic used in M4.

>

> Tested by building cross and candian cross toolchain (host:

> i686-w64-mingw32) for arm-linux-gnueabihf with issue and with a

> complete libgomp.

>

> ok for trunk ?


ping?

> Thanks

> Yvan

>

> config/ChangeLog

> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>

>         * acx.m4 (NCN_STRICT_CHECK_TARGET_TOOLS): Renamed to ...

>         (NCN_STRICT_PATH_TARGET_TOOLS): ... this.  It reflects the replacement

>         of AC_CHECK_PROG by AC_PATH_PROG to get the absolute name of the

>         program.

>         (ACX_CHECK_INSTALLED_TARGET_TOOL): Use renamed function.

>

> ChangeLog

> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>

>         * configure.ac: Use NCN_STRICT_PATH_TARGET_TOOLS instead of

>         NCN_STRICT_CHECK_TARGET_TOOLS.

>         * configure: Regenerate.
Yvan Roux July 11, 2017, 10:25 a.m. | #2
On 3 July 2017 at 11:21, Yvan Roux <yvan.roux@linaro.org> wrote:
> On 23 June 2017 at 15:44, Yvan Roux <yvan.roux@linaro.org> wrote:

>> Hello,

>>

>> Fortran parts of libgomp (omp_lib.mod, openacc.mod, etc...) are

>> missing in a canadian cross build, at least when target gfortran

>> compiler comes from PATH and not from GFORTRAN_FOR_TARGET.

>>

>> Back in 2010, executability test of GFORTRAN was added to fix libgomp

>> build on cygwin, but when the executable doesn't contain the path,

>> "test -x" fails and part of the library are not built.

>>

>> This patch fixes the issue by using M4 macro AC_PATH_PROG (which

>> returns the absolute name) instead of AC_CHECK_PROG in the function

>> defined in config/acx.m4: NCN_STRICT_CHECK_TARGET_TOOLS.  I renamed it

>> into NCN_STRICT_PATH_TARGET_TOOLS to keep the semantic used in M4.

>>

>> Tested by building cross and candian cross toolchain (host:

>> i686-w64-mingw32) for arm-linux-gnueabihf with issue and with a

>> complete libgomp.

>>

>> ok for trunk ?

>

> ping?


ping?

>

>> Thanks

>> Yvan

>>

>> config/ChangeLog

>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>

>>         * acx.m4 (NCN_STRICT_CHECK_TARGET_TOOLS): Renamed to ...

>>         (NCN_STRICT_PATH_TARGET_TOOLS): ... this.  It reflects the replacement

>>         of AC_CHECK_PROG by AC_PATH_PROG to get the absolute name of the

>>         program.

>>         (ACX_CHECK_INSTALLED_TARGET_TOOL): Use renamed function.

>>

>> ChangeLog

>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>

>>         * configure.ac: Use NCN_STRICT_PATH_TARGET_TOOLS instead of

>>         NCN_STRICT_CHECK_TARGET_TOOLS.

>>         * configure: Regenerate.
Yvan Roux Aug. 4, 2017, 1:52 p.m. | #3
On 11 July 2017 at 12:25, Yvan Roux <yvan.roux@linaro.org> wrote:
> On 3 July 2017 at 11:21, Yvan Roux <yvan.roux@linaro.org> wrote:

>> On 23 June 2017 at 15:44, Yvan Roux <yvan.roux@linaro.org> wrote:

>>> Hello,

>>>

>>> Fortran parts of libgomp (omp_lib.mod, openacc.mod, etc...) are

>>> missing in a canadian cross build, at least when target gfortran

>>> compiler comes from PATH and not from GFORTRAN_FOR_TARGET.

>>>

>>> Back in 2010, executability test of GFORTRAN was added to fix libgomp

>>> build on cygwin, but when the executable doesn't contain the path,

>>> "test -x" fails and part of the library are not built.

>>>

>>> This patch fixes the issue by using M4 macro AC_PATH_PROG (which

>>> returns the absolute name) instead of AC_CHECK_PROG in the function

>>> defined in config/acx.m4: NCN_STRICT_CHECK_TARGET_TOOLS.  I renamed it

>>> into NCN_STRICT_PATH_TARGET_TOOLS to keep the semantic used in M4.

>>>

>>> Tested by building cross and candian cross toolchain (host:

>>> i686-w64-mingw32) for arm-linux-gnueabihf with issue and with a

>>> complete libgomp.

>>>

>>> ok for trunk ?

>>

>> ping?

>

> ping?


ping

>>

>>> Thanks

>>> Yvan

>>>

>>> config/ChangeLog

>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>>

>>>         * acx.m4 (NCN_STRICT_CHECK_TARGET_TOOLS): Renamed to ...

>>>         (NCN_STRICT_PATH_TARGET_TOOLS): ... this.  It reflects the replacement

>>>         of AC_CHECK_PROG by AC_PATH_PROG to get the absolute name of the

>>>         program.

>>>         (ACX_CHECK_INSTALLED_TARGET_TOOL): Use renamed function.

>>>

>>> ChangeLog

>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>>

>>>         * configure.ac: Use NCN_STRICT_PATH_TARGET_TOOLS instead of

>>>         NCN_STRICT_CHECK_TARGET_TOOLS.

>>>         * configure: Regenerate.
Yvan Roux Aug. 18, 2017, 8:27 a.m. | #4
On 4 August 2017 at 15:52, Yvan Roux <yvan.roux@linaro.org> wrote:
> On 11 July 2017 at 12:25, Yvan Roux <yvan.roux@linaro.org> wrote:

>> On 3 July 2017 at 11:21, Yvan Roux <yvan.roux@linaro.org> wrote:

>>> On 23 June 2017 at 15:44, Yvan Roux <yvan.roux@linaro.org> wrote:

>>>> Hello,

>>>>

>>>> Fortran parts of libgomp (omp_lib.mod, openacc.mod, etc...) are

>>>> missing in a canadian cross build, at least when target gfortran

>>>> compiler comes from PATH and not from GFORTRAN_FOR_TARGET.

>>>>

>>>> Back in 2010, executability test of GFORTRAN was added to fix libgomp

>>>> build on cygwin, but when the executable doesn't contain the path,

>>>> "test -x" fails and part of the library are not built.

>>>>

>>>> This patch fixes the issue by using M4 macro AC_PATH_PROG (which

>>>> returns the absolute name) instead of AC_CHECK_PROG in the function

>>>> defined in config/acx.m4: NCN_STRICT_CHECK_TARGET_TOOLS.  I renamed it

>>>> into NCN_STRICT_PATH_TARGET_TOOLS to keep the semantic used in M4.

>>>>

>>>> Tested by building cross and candian cross toolchain (host:

>>>> i686-w64-mingw32) for arm-linux-gnueabihf with issue and with a

>>>> complete libgomp.

>>>>

>>>> ok for trunk ?

>>>

>>> ping?

>>

>> ping?

>

> ping


ping

https://gcc.gnu.org/ml/gcc-patches/2017-06/msg01784.html

>>>

>>>> Thanks

>>>> Yvan

>>>>

>>>> config/ChangeLog

>>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>>>

>>>>         * acx.m4 (NCN_STRICT_CHECK_TARGET_TOOLS): Renamed to ...

>>>>         (NCN_STRICT_PATH_TARGET_TOOLS): ... this.  It reflects the replacement

>>>>         of AC_CHECK_PROG by AC_PATH_PROG to get the absolute name of the

>>>>         program.

>>>>         (ACX_CHECK_INSTALLED_TARGET_TOOL): Use renamed function.

>>>>

>>>> ChangeLog

>>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>>>

>>>>         * configure.ac: Use NCN_STRICT_PATH_TARGET_TOOLS instead of

>>>>         NCN_STRICT_CHECK_TARGET_TOOLS.

>>>>         * configure: Regenerate.
Yvan Roux Sept. 5, 2017, 8:58 a.m. | #5
On 18 August 2017 at 10:27, Yvan Roux <yvan.roux@linaro.org> wrote:
> On 4 August 2017 at 15:52, Yvan Roux <yvan.roux@linaro.org> wrote:

>> On 11 July 2017 at 12:25, Yvan Roux <yvan.roux@linaro.org> wrote:

>>> On 3 July 2017 at 11:21, Yvan Roux <yvan.roux@linaro.org> wrote:

>>>> On 23 June 2017 at 15:44, Yvan Roux <yvan.roux@linaro.org> wrote:

>>>>> Hello,

>>>>>

>>>>> Fortran parts of libgomp (omp_lib.mod, openacc.mod, etc...) are

>>>>> missing in a canadian cross build, at least when target gfortran

>>>>> compiler comes from PATH and not from GFORTRAN_FOR_TARGET.

>>>>>

>>>>> Back in 2010, executability test of GFORTRAN was added to fix libgomp

>>>>> build on cygwin, but when the executable doesn't contain the path,

>>>>> "test -x" fails and part of the library are not built.

>>>>>

>>>>> This patch fixes the issue by using M4 macro AC_PATH_PROG (which

>>>>> returns the absolute name) instead of AC_CHECK_PROG in the function

>>>>> defined in config/acx.m4: NCN_STRICT_CHECK_TARGET_TOOLS.  I renamed it

>>>>> into NCN_STRICT_PATH_TARGET_TOOLS to keep the semantic used in M4.

>>>>>

>>>>> Tested by building cross and candian cross toolchain (host:

>>>>> i686-w64-mingw32) for arm-linux-gnueabihf with issue and with a

>>>>> complete libgomp.

>>>>>

>>>>> ok for trunk ?

>>>>

>>>> ping?

>>>

>>> ping?

>>

>> ping

>

> ping

>

> https://gcc.gnu.org/ml/gcc-patches/2017-06/msg01784.html


ping

https://gcc.gnu.org/ml/gcc-patches/2017-06/msg01784.html

>>>>

>>>>> Thanks

>>>>> Yvan

>>>>>

>>>>> config/ChangeLog

>>>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>>>>

>>>>>         * acx.m4 (NCN_STRICT_CHECK_TARGET_TOOLS): Renamed to ...

>>>>>         (NCN_STRICT_PATH_TARGET_TOOLS): ... this.  It reflects the replacement

>>>>>         of AC_CHECK_PROG by AC_PATH_PROG to get the absolute name of the

>>>>>         program.

>>>>>         (ACX_CHECK_INSTALLED_TARGET_TOOL): Use renamed function.

>>>>>

>>>>> ChangeLog

>>>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

>>>>>

>>>>>         * configure.ac: Use NCN_STRICT_PATH_TARGET_TOOLS instead of

>>>>>         NCN_STRICT_CHECK_TARGET_TOOLS.

>>>>>         * configure: Regenerate.
Jakub Jelinek Sept. 5, 2017, 10:04 a.m. | #6
On Tue, Sep 05, 2017 at 10:58:22AM +0200, Yvan Roux wrote:
> ping

> 

> https://gcc.gnu.org/ml/gcc-patches/2017-06/msg01784.html


This really needs to be reviewed by a build machinery maintainer.

> >>>>> config/ChangeLog

> >>>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

> >>>>>

> >>>>>         * acx.m4 (NCN_STRICT_CHECK_TARGET_TOOLS): Renamed to ...

> >>>>>         (NCN_STRICT_PATH_TARGET_TOOLS): ... this.  It reflects the replacement

> >>>>>         of AC_CHECK_PROG by AC_PATH_PROG to get the absolute name of the

> >>>>>         program.

> >>>>>         (ACX_CHECK_INSTALLED_TARGET_TOOL): Use renamed function.

> >>>>>

> >>>>> ChangeLog

> >>>>> 2017-06-23  Yvan Roux  <yvan.roux@linaro.org>

> >>>>>

> >>>>>         * configure.ac: Use NCN_STRICT_PATH_TARGET_TOOLS instead of

> >>>>>         NCN_STRICT_CHECK_TARGET_TOOLS.

> >>>>>         * configure: Regenerate.


	Jakub

Patch

diff --git a/config/acx.m4 b/config/acx.m4
index aa1d34b..ede303c 100644
--- a/config/acx.m4
+++ b/config/acx.m4
@@ -159,30 +159,30 @@  fi
 ]) []dnl # NCN_STRICT_CHECK_TOOLS
 
 ####
-# NCN_STRICT_CHECK_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
-# Like CVS Autoconf AC_CHECK_TARGET_TOOLS, but require prefix if build!=target.
+# NCN_STRICT_PATH_TARGET_TOOLS(variable, progs-to-check-for,[value-if-not-found],[path])
+# Like CVS Autoconf AC_PATH_TARGET_TOOLS, but require prefix if build!=target.
 
-AC_DEFUN([NCN_STRICT_CHECK_TARGET_TOOLS],
+AC_DEFUN([NCN_STRICT_PATH_TARGET_TOOLS],
 [AC_REQUIRE([_NCN_TOOL_PREFIXES]) []dnl
 AC_ARG_VAR([$1], patsubst([$1], [_FOR_TARGET$], [])[ for the target])
 
 if test -n "[$]$1"; then
-  ac_cv_prog_$1=[$]$1
-elif test -n "$ac_cv_prog_$1"; then
-  $1=$ac_cv_prog_$1
+  ac_cv_path_$1=[$]$1
+elif test -n "$ac_cv_path_$1"; then
+  $1=$ac_cv_path_$1
 fi
 
-if test -n "$ac_cv_prog_$1"; then
+if test -n "$ac_cv_path_$1"; then
   for ncn_progname in $2; do
-    AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4])
+    AC_PATH_PROG([$1], [${ncn_progname}], , [$4])
   done
 fi
 
-if test -z "$ac_cv_prog_$1" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_$1" && test -n "$with_build_time_tools"; then
   for ncn_progname in $2; do
     AC_MSG_CHECKING([for ${ncn_progname} in $with_build_time_tools])
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_$1=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_$1=$with_build_time_tools/${ncn_progname}
       AC_MSG_RESULT(yes)
       break
     else
@@ -191,20 +191,19 @@  if test -z "$ac_cv_prog_$1" && test -n "$with_build_time_tools"; then
   done
 fi
 
-if test -z "$ac_cv_prog_$1"; then
+if test -z "$ac_cv_path_$1"; then
   for ncn_progname in $2; do
     if test -n "$ncn_target_tool_prefix"; then
-      AC_CHECK_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}], 
-                    [${ncn_target_tool_prefix}${ncn_progname}], , [$4])
+      AC_PATH_PROG([$1], [${ncn_target_tool_prefix}${ncn_progname}], , [$4])
     fi
-    if test -z "$ac_cv_prog_$1" && test $build = $target ; then
-      AC_CHECK_PROG([$1], [${ncn_progname}], [${ncn_progname}], , [$4]) 
+    if test -z "$ac_cv_path_$1" && test $build = $target ; then
+      AC_PATH_PROG([$1], [${ncn_progname}], , [$4])
     fi
-    test -n "$ac_cv_prog_$1" && break
+    test -n "$ac_cv_path_$1" && break
   done
 fi
   
-if test -z "$ac_cv_prog_$1" ; then
+if test -z "$ac_cv_path_$1" ; then
   ifelse([$3],[], [set dummy $2
   if test $build = $target ; then
     $1="[$]2"
@@ -212,9 +211,9 @@  if test -z "$ac_cv_prog_$1" ; then
     $1="${ncn_target_tool_prefix}[$]2"
   fi], [$1="$3"])
 else
-  $1="$ac_cv_prog_$1"
+  $1="$ac_cv_path_$1"
 fi
-]) []dnl # NCN_STRICT_CHECK_TARGET_TOOLS
+]) []dnl # NCN_STRICT_PATH_TARGET_TOOLS
   
 
 # Backported from Autoconf 2.5x; can go away when and if
@@ -360,7 +359,7 @@  if test -z "$ac_cv_path_$1" && test -n "$gcc_cv_tool_dirs"; then
   AC_PATH_PROG([$1], [$2], [], [$gcc_cv_tool_dirs])
 fi
 if test -z "$ac_cv_path_$1" ; then
-  NCN_STRICT_CHECK_TARGET_TOOLS([$1], [$2])
+  NCN_STRICT_PATH_TARGET_TOOLS([$1], [$2])
 else
   $1=$ac_cv_path_$1
 fi
diff --git a/configure b/configure
index 084986f..a763d76 100755
--- a/configure
+++ b/configure
@@ -9943,31 +9943,33 @@  fi
 
 
 if test -n "$CC_FOR_TARGET"; then
-  ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
-elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
-  CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
+  ac_cv_path_CC_FOR_TARGET=$CC_FOR_TARGET
+elif test -n "$ac_cv_path_CC_FOR_TARGET"; then
+  CC_FOR_TARGET=$ac_cv_path_CC_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
+if test -n "$ac_cv_path_CC_FOR_TARGET"; then
   for ncn_progname in cc gcc; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_CC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$CC_FOR_TARGET"; then
-  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $CC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_CC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -9975,9 +9977,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
+CC_FOR_TARGET=$ac_cv_path_CC_FOR_TARGET
 if test -n "$CC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_TARGET" >&5
 $as_echo "$CC_FOR_TARGET" >&6; }
@@ -9990,12 +9993,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in cc gcc; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -10006,27 +10009,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
+if test -z "$ac_cv_path_CC_FOR_TARGET"; then
   for ncn_progname in cc gcc; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_CC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$CC_FOR_TARGET"; then
-  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $CC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_CC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10034,9 +10039,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
+CC_FOR_TARGET=$ac_cv_path_CC_FOR_TARGET
 if test -n "$CC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_TARGET" >&5
 $as_echo "$CC_FOR_TARGET" >&6; }
@@ -10047,25 +10053,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_CC_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_CC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$CC_FOR_TARGET"; then
-  ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $CC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_CC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10073,9 +10081,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
+CC_FOR_TARGET=$ac_cv_path_CC_FOR_TARGET
 if test -n "$CC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_TARGET" >&5
 $as_echo "$CC_FOR_TARGET" >&6; }
@@ -10086,11 +10095,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_CC_FOR_TARGET" && break
+    test -n "$ac_cv_path_CC_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
+if test -z "$ac_cv_path_CC_FOR_TARGET" ; then
   set dummy cc gcc
   if test $build = $target ; then
     CC_FOR_TARGET="$2"
@@ -10098,37 +10107,39 @@  if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
+  CC_FOR_TARGET="$ac_cv_path_CC_FOR_TARGET"
 fi
 
 
 
 if test -n "$CXX_FOR_TARGET"; then
-  ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
-elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
-  CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
+  ac_cv_path_CXX_FOR_TARGET=$CXX_FOR_TARGET
+elif test -n "$ac_cv_path_CXX_FOR_TARGET"; then
+  CXX_FOR_TARGET=$ac_cv_path_CXX_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
+if test -n "$ac_cv_path_CXX_FOR_TARGET"; then
   for ncn_progname in c++ g++ cxx gxx; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_CXX_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$CXX_FOR_TARGET"; then
-  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $CXX_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_CXX_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10136,9 +10147,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
+CXX_FOR_TARGET=$ac_cv_path_CXX_FOR_TARGET
 if test -n "$CXX_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FOR_TARGET" >&5
 $as_echo "$CXX_FOR_TARGET" >&6; }
@@ -10151,12 +10163,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in c++ g++ cxx gxx; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -10167,27 +10179,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
+if test -z "$ac_cv_path_CXX_FOR_TARGET"; then
   for ncn_progname in c++ g++ cxx gxx; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_CXX_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$CXX_FOR_TARGET"; then
-  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $CXX_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_CXX_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10195,9 +10209,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
+CXX_FOR_TARGET=$ac_cv_path_CXX_FOR_TARGET
 if test -n "$CXX_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FOR_TARGET" >&5
 $as_echo "$CXX_FOR_TARGET" >&6; }
@@ -10208,25 +10223,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_CXX_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_CXX_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$CXX_FOR_TARGET"; then
-  ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $CXX_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_CXX_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10234,9 +10251,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
+CXX_FOR_TARGET=$ac_cv_path_CXX_FOR_TARGET
 if test -n "$CXX_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FOR_TARGET" >&5
 $as_echo "$CXX_FOR_TARGET" >&6; }
@@ -10247,11 +10265,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
+    test -n "$ac_cv_path_CXX_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
+if test -z "$ac_cv_path_CXX_FOR_TARGET" ; then
   set dummy c++ g++ cxx gxx
   if test $build = $target ; then
     CXX_FOR_TARGET="$2"
@@ -10259,37 +10277,39 @@  if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
+  CXX_FOR_TARGET="$ac_cv_path_CXX_FOR_TARGET"
 fi
 
 
 
 if test -n "$GCC_FOR_TARGET"; then
-  ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
-elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
-  GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
+  ac_cv_path_GCC_FOR_TARGET=$GCC_FOR_TARGET
+elif test -n "$ac_cv_path_GCC_FOR_TARGET"; then
+  GCC_FOR_TARGET=$ac_cv_path_GCC_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
+if test -n "$ac_cv_path_GCC_FOR_TARGET"; then
   for ncn_progname in gcc; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GCC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GCC_FOR_TARGET"; then
-  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GCC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_GCC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10297,9 +10317,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
+GCC_FOR_TARGET=$ac_cv_path_GCC_FOR_TARGET
 if test -n "$GCC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCC_FOR_TARGET" >&5
 $as_echo "$GCC_FOR_TARGET" >&6; }
@@ -10312,12 +10333,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in gcc; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -10328,27 +10349,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
+if test -z "$ac_cv_path_GCC_FOR_TARGET"; then
   for ncn_progname in gcc; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GCC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GCC_FOR_TARGET"; then
-  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GCC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_GCC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10356,9 +10379,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
+GCC_FOR_TARGET=$ac_cv_path_GCC_FOR_TARGET
 if test -n "$GCC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCC_FOR_TARGET" >&5
 $as_echo "$GCC_FOR_TARGET" >&6; }
@@ -10369,25 +10393,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_GCC_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GCC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GCC_FOR_TARGET"; then
-  ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GCC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_GCC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10395,9 +10421,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
+GCC_FOR_TARGET=$ac_cv_path_GCC_FOR_TARGET
 if test -n "$GCC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GCC_FOR_TARGET" >&5
 $as_echo "$GCC_FOR_TARGET" >&6; }
@@ -10408,44 +10435,46 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
+    test -n "$ac_cv_path_GCC_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
+if test -z "$ac_cv_path_GCC_FOR_TARGET" ; then
   GCC_FOR_TARGET="${CC_FOR_TARGET}"
 else
-  GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
+  GCC_FOR_TARGET="$ac_cv_path_GCC_FOR_TARGET"
 fi
 
 
 
 if test -n "$GFORTRAN_FOR_TARGET"; then
-  ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
-elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
-  GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
+  ac_cv_path_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
+elif test -n "$ac_cv_path_GFORTRAN_FOR_TARGET"; then
+  GFORTRAN_FOR_TARGET=$ac_cv_path_GFORTRAN_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
+if test -n "$ac_cv_path_GFORTRAN_FOR_TARGET"; then
   for ncn_progname in gfortran; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GFORTRAN_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GFORTRAN_FOR_TARGET"; then
-  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GFORTRAN_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_GFORTRAN_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10453,9 +10482,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
+GFORTRAN_FOR_TARGET=$ac_cv_path_GFORTRAN_FOR_TARGET
 if test -n "$GFORTRAN_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GFORTRAN_FOR_TARGET" >&5
 $as_echo "$GFORTRAN_FOR_TARGET" >&6; }
@@ -10468,12 +10498,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in gfortran; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -10484,27 +10514,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
+if test -z "$ac_cv_path_GFORTRAN_FOR_TARGET"; then
   for ncn_progname in gfortran; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GFORTRAN_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GFORTRAN_FOR_TARGET"; then
-  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GFORTRAN_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_GFORTRAN_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10512,9 +10544,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
+GFORTRAN_FOR_TARGET=$ac_cv_path_GFORTRAN_FOR_TARGET
 if test -n "$GFORTRAN_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GFORTRAN_FOR_TARGET" >&5
 $as_echo "$GFORTRAN_FOR_TARGET" >&6; }
@@ -10525,25 +10558,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_GFORTRAN_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GFORTRAN_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GFORTRAN_FOR_TARGET"; then
-  ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GFORTRAN_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_GFORTRAN_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10551,9 +10586,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
+GFORTRAN_FOR_TARGET=$ac_cv_path_GFORTRAN_FOR_TARGET
 if test -n "$GFORTRAN_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GFORTRAN_FOR_TARGET" >&5
 $as_echo "$GFORTRAN_FOR_TARGET" >&6; }
@@ -10564,11 +10600,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
+    test -n "$ac_cv_path_GFORTRAN_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
+if test -z "$ac_cv_path_GFORTRAN_FOR_TARGET" ; then
   set dummy gfortran
   if test $build = $target ; then
     GFORTRAN_FOR_TARGET="$2"
@@ -10576,37 +10612,39 @@  if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
+  GFORTRAN_FOR_TARGET="$ac_cv_path_GFORTRAN_FOR_TARGET"
 fi
 
 
 
 if test -n "$GOC_FOR_TARGET"; then
-  ac_cv_prog_GOC_FOR_TARGET=$GOC_FOR_TARGET
-elif test -n "$ac_cv_prog_GOC_FOR_TARGET"; then
-  GOC_FOR_TARGET=$ac_cv_prog_GOC_FOR_TARGET
+  ac_cv_path_GOC_FOR_TARGET=$GOC_FOR_TARGET
+elif test -n "$ac_cv_path_GOC_FOR_TARGET"; then
+  GOC_FOR_TARGET=$ac_cv_path_GOC_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_GOC_FOR_TARGET"; then
+if test -n "$ac_cv_path_GOC_FOR_TARGET"; then
   for ncn_progname in gccgo; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GOC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GOC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GOC_FOR_TARGET"; then
-  ac_cv_prog_GOC_FOR_TARGET="$GOC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GOC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GOC_FOR_TARGET="$GOC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GOC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_GOC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10614,9 +10652,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GOC_FOR_TARGET=$ac_cv_prog_GOC_FOR_TARGET
+GOC_FOR_TARGET=$ac_cv_path_GOC_FOR_TARGET
 if test -n "$GOC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GOC_FOR_TARGET" >&5
 $as_echo "$GOC_FOR_TARGET" >&6; }
@@ -10629,12 +10668,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_GOC_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_GOC_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in gccgo; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_GOC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_GOC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -10645,27 +10684,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_GOC_FOR_TARGET"; then
+if test -z "$ac_cv_path_GOC_FOR_TARGET"; then
   for ncn_progname in gccgo; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GOC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GOC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GOC_FOR_TARGET"; then
-  ac_cv_prog_GOC_FOR_TARGET="$GOC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GOC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GOC_FOR_TARGET="$GOC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GOC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_GOC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10673,9 +10714,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GOC_FOR_TARGET=$ac_cv_prog_GOC_FOR_TARGET
+GOC_FOR_TARGET=$ac_cv_path_GOC_FOR_TARGET
 if test -n "$GOC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GOC_FOR_TARGET" >&5
 $as_echo "$GOC_FOR_TARGET" >&6; }
@@ -10686,25 +10728,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_GOC_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_GOC_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_GOC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_GOC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$GOC_FOR_TARGET"; then
-  ac_cv_prog_GOC_FOR_TARGET="$GOC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $GOC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_GOC_FOR_TARGET="$GOC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_GOC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_GOC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10712,9 +10756,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-GOC_FOR_TARGET=$ac_cv_prog_GOC_FOR_TARGET
+GOC_FOR_TARGET=$ac_cv_path_GOC_FOR_TARGET
 if test -n "$GOC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GOC_FOR_TARGET" >&5
 $as_echo "$GOC_FOR_TARGET" >&6; }
@@ -10725,11 +10770,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_GOC_FOR_TARGET" && break
+    test -n "$ac_cv_path_GOC_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_GOC_FOR_TARGET" ; then
+if test -z "$ac_cv_path_GOC_FOR_TARGET" ; then
   set dummy gccgo
   if test $build = $target ; then
     GOC_FOR_TARGET="$2"
@@ -10737,7 +10782,7 @@  if test -z "$ac_cv_prog_GOC_FOR_TARGET" ; then
     GOC_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  GOC_FOR_TARGET="$ac_cv_prog_GOC_FOR_TARGET"
+  GOC_FOR_TARGET="$ac_cv_path_GOC_FOR_TARGET"
 fi
 
 
@@ -10823,31 +10868,33 @@  if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
 
 
 if test -n "$AR_FOR_TARGET"; then
-  ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
-elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
-  AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
+  ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
+elif test -n "$ac_cv_path_AR_FOR_TARGET"; then
+  AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
+if test -n "$ac_cv_path_AR_FOR_TARGET"; then
   for ncn_progname in ar; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$AR_FOR_TARGET"; then
-  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $AR_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10855,9 +10902,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
+AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
 if test -n "$AR_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR_FOR_TARGET" >&5
 $as_echo "$AR_FOR_TARGET" >&6; }
@@ -10870,12 +10918,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in ar; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -10886,27 +10934,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
+if test -z "$ac_cv_path_AR_FOR_TARGET"; then
   for ncn_progname in ar; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$AR_FOR_TARGET"; then
-  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $AR_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10914,9 +10964,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
+AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
 if test -n "$AR_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR_FOR_TARGET" >&5
 $as_echo "$AR_FOR_TARGET" >&6; }
@@ -10927,25 +10978,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_AR_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$AR_FOR_TARGET"; then
-  ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $AR_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -10953,9 +11006,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
+AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
 if test -n "$AR_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR_FOR_TARGET" >&5
 $as_echo "$AR_FOR_TARGET" >&6; }
@@ -10966,11 +11020,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_AR_FOR_TARGET" && break
+    test -n "$ac_cv_path_AR_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
+if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
   set dummy ar
   if test $build = $target ; then
     AR_FOR_TARGET="$2"
@@ -10978,7 +11032,7 @@  if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
+  AR_FOR_TARGET="$ac_cv_path_AR_FOR_TARGET"
 fi
 
 else
@@ -11053,31 +11107,33 @@  if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
 
 
 if test -n "$AS_FOR_TARGET"; then
-  ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
-elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
-  AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
+  ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
+elif test -n "$ac_cv_path_AS_FOR_TARGET"; then
+  AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
+if test -n "$ac_cv_path_AS_FOR_TARGET"; then
   for ncn_progname in as; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$AS_FOR_TARGET"; then
-  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $AS_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11085,9 +11141,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
+AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
 if test -n "$AS_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS_FOR_TARGET" >&5
 $as_echo "$AS_FOR_TARGET" >&6; }
@@ -11100,12 +11157,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in as; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -11116,27 +11173,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
+if test -z "$ac_cv_path_AS_FOR_TARGET"; then
   for ncn_progname in as; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$AS_FOR_TARGET"; then
-  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $AS_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11144,9 +11203,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
+AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
 if test -n "$AS_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS_FOR_TARGET" >&5
 $as_echo "$AS_FOR_TARGET" >&6; }
@@ -11157,25 +11217,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_AS_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$AS_FOR_TARGET"; then
-  ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $AS_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11183,9 +11245,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
+AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
 if test -n "$AS_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS_FOR_TARGET" >&5
 $as_echo "$AS_FOR_TARGET" >&6; }
@@ -11196,11 +11259,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_AS_FOR_TARGET" && break
+    test -n "$ac_cv_path_AS_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
+if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
   set dummy as
   if test $build = $target ; then
     AS_FOR_TARGET="$2"
@@ -11208,7 +11271,7 @@  if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
+  AS_FOR_TARGET="$ac_cv_path_AS_FOR_TARGET"
 fi
 
 else
@@ -11283,31 +11346,33 @@  if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
 
 
 if test -n "$DLLTOOL_FOR_TARGET"; then
-  ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
-elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
-  DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
+  ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
+elif test -n "$ac_cv_path_DLLTOOL_FOR_TARGET"; then
+  DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
+if test -n "$ac_cv_path_DLLTOOL_FOR_TARGET"; then
   for ncn_progname in dlltool; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$DLLTOOL_FOR_TARGET"; then
-  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $DLLTOOL_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11315,9 +11380,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
+DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
 if test -n "$DLLTOOL_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL_FOR_TARGET" >&5
 $as_echo "$DLLTOOL_FOR_TARGET" >&6; }
@@ -11330,12 +11396,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in dlltool; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -11346,27 +11412,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
+if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET"; then
   for ncn_progname in dlltool; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$DLLTOOL_FOR_TARGET"; then
-  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $DLLTOOL_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11374,9 +11442,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
+DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
 if test -n "$DLLTOOL_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL_FOR_TARGET" >&5
 $as_echo "$DLLTOOL_FOR_TARGET" >&6; }
@@ -11387,25 +11456,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$DLLTOOL_FOR_TARGET"; then
-  ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
+  case $DLLTOOL_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11413,9 +11484,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
+DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
 if test -n "$DLLTOOL_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL_FOR_TARGET" >&5
 $as_echo "$DLLTOOL_FOR_TARGET" >&6; }
@@ -11426,11 +11498,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
+    test -n "$ac_cv_path_DLLTOOL_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
+if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
   set dummy dlltool
   if test $build = $target ; then
     DLLTOOL_FOR_TARGET="$2"
@@ -11438,7 +11510,7 @@  if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
+  DLLTOOL_FOR_TARGET="$ac_cv_path_DLLTOOL_FOR_TARGET"
 fi
 
 else
@@ -11513,31 +11585,33 @@  if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
 
 
 if test -n "$LD_FOR_TARGET"; then
-  ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
-elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
-  LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
+  ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
+elif test -n "$ac_cv_path_LD_FOR_TARGET"; then
+  LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
+if test -n "$ac_cv_path_LD_FOR_TARGET"; then
   for ncn_progname in ld; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$LD_FOR_TARGET"; then
-  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $LD_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11545,9 +11619,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
+LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
 if test -n "$LD_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD_FOR_TARGET" >&5
 $as_echo "$LD_FOR_TARGET" >&6; }
@@ -11560,12 +11635,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in ld; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -11576,27 +11651,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
+if test -z "$ac_cv_path_LD_FOR_TARGET"; then
   for ncn_progname in ld; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$LD_FOR_TARGET"; then
-  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $LD_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11604,9 +11681,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
+LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
 if test -n "$LD_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD_FOR_TARGET" >&5
 $as_echo "$LD_FOR_TARGET" >&6; }
@@ -11617,25 +11695,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_LD_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$LD_FOR_TARGET"; then
-  ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $LD_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11643,9 +11723,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
+LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
 if test -n "$LD_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD_FOR_TARGET" >&5
 $as_echo "$LD_FOR_TARGET" >&6; }
@@ -11656,11 +11737,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_LD_FOR_TARGET" && break
+    test -n "$ac_cv_path_LD_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
+if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
   set dummy ld
   if test $build = $target ; then
     LD_FOR_TARGET="$2"
@@ -11668,7 +11749,7 @@  if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
+  LD_FOR_TARGET="$ac_cv_path_LD_FOR_TARGET"
 fi
 
 else
@@ -11743,31 +11824,33 @@  if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
 
 
 if test -n "$LIPO_FOR_TARGET"; then
-  ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
-elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
-  LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
+  ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
+elif test -n "$ac_cv_path_LIPO_FOR_TARGET"; then
+  LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
+if test -n "$ac_cv_path_LIPO_FOR_TARGET"; then
   for ncn_progname in lipo; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$LIPO_FOR_TARGET"; then
-  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $LIPO_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11775,9 +11858,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
+LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
 if test -n "$LIPO_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO_FOR_TARGET" >&5
 $as_echo "$LIPO_FOR_TARGET" >&6; }
@@ -11790,12 +11874,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in lipo; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -11806,27 +11890,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
+if test -z "$ac_cv_path_LIPO_FOR_TARGET"; then
   for ncn_progname in lipo; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$LIPO_FOR_TARGET"; then
-  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $LIPO_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11834,9 +11920,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
+LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
 if test -n "$LIPO_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO_FOR_TARGET" >&5
 $as_echo "$LIPO_FOR_TARGET" >&6; }
@@ -11847,25 +11934,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$LIPO_FOR_TARGET"; then
-  ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $LIPO_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -11873,9 +11962,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
+LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
 if test -n "$LIPO_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO_FOR_TARGET" >&5
 $as_echo "$LIPO_FOR_TARGET" >&6; }
@@ -11886,11 +11976,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
+    test -n "$ac_cv_path_LIPO_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
+if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
   set dummy lipo
   if test $build = $target ; then
     LIPO_FOR_TARGET="$2"
@@ -11898,7 +11988,7 @@  if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
+  LIPO_FOR_TARGET="$ac_cv_path_LIPO_FOR_TARGET"
 fi
 
 else
@@ -11973,31 +12063,33 @@  if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
 
 
 if test -n "$NM_FOR_TARGET"; then
-  ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
-elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
-  NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
+  ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
+elif test -n "$ac_cv_path_NM_FOR_TARGET"; then
+  NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
+if test -n "$ac_cv_path_NM_FOR_TARGET"; then
   for ncn_progname in nm; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$NM_FOR_TARGET"; then
-  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $NM_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12005,9 +12097,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
+NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
 if test -n "$NM_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM_FOR_TARGET" >&5
 $as_echo "$NM_FOR_TARGET" >&6; }
@@ -12020,12 +12113,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in nm; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -12036,27 +12129,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
+if test -z "$ac_cv_path_NM_FOR_TARGET"; then
   for ncn_progname in nm; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$NM_FOR_TARGET"; then
-  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $NM_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12064,9 +12159,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
+NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
 if test -n "$NM_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM_FOR_TARGET" >&5
 $as_echo "$NM_FOR_TARGET" >&6; }
@@ -12077,25 +12173,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_NM_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$NM_FOR_TARGET"; then
-  ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $NM_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12103,9 +12201,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
+NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
 if test -n "$NM_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM_FOR_TARGET" >&5
 $as_echo "$NM_FOR_TARGET" >&6; }
@@ -12116,11 +12215,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_NM_FOR_TARGET" && break
+    test -n "$ac_cv_path_NM_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
+if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
   set dummy nm
   if test $build = $target ; then
     NM_FOR_TARGET="$2"
@@ -12128,7 +12227,7 @@  if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
+  NM_FOR_TARGET="$ac_cv_path_NM_FOR_TARGET"
 fi
 
 else
@@ -12203,31 +12302,33 @@  if test -z "$ac_cv_path_OBJCOPY_FOR_TARGET" ; then
 
 
 if test -n "$OBJCOPY_FOR_TARGET"; then
-  ac_cv_prog_OBJCOPY_FOR_TARGET=$OBJCOPY_FOR_TARGET
-elif test -n "$ac_cv_prog_OBJCOPY_FOR_TARGET"; then
-  OBJCOPY_FOR_TARGET=$ac_cv_prog_OBJCOPY_FOR_TARGET
+  ac_cv_path_OBJCOPY_FOR_TARGET=$OBJCOPY_FOR_TARGET
+elif test -n "$ac_cv_path_OBJCOPY_FOR_TARGET"; then
+  OBJCOPY_FOR_TARGET=$ac_cv_path_OBJCOPY_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_OBJCOPY_FOR_TARGET"; then
+if test -n "$ac_cv_path_OBJCOPY_FOR_TARGET"; then
   for ncn_progname in objcopy; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_OBJCOPY_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_OBJCOPY_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$OBJCOPY_FOR_TARGET"; then
-  ac_cv_prog_OBJCOPY_FOR_TARGET="$OBJCOPY_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $OBJCOPY_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_OBJCOPY_FOR_TARGET="$OBJCOPY_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_OBJCOPY_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_OBJCOPY_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12235,9 +12336,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-OBJCOPY_FOR_TARGET=$ac_cv_prog_OBJCOPY_FOR_TARGET
+OBJCOPY_FOR_TARGET=$ac_cv_path_OBJCOPY_FOR_TARGET
 if test -n "$OBJCOPY_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY_FOR_TARGET" >&5
 $as_echo "$OBJCOPY_FOR_TARGET" >&6; }
@@ -12250,12 +12352,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_OBJCOPY_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_OBJCOPY_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in objcopy; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_OBJCOPY_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_OBJCOPY_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -12266,27 +12368,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_OBJCOPY_FOR_TARGET"; then
+if test -z "$ac_cv_path_OBJCOPY_FOR_TARGET"; then
   for ncn_progname in objcopy; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_OBJCOPY_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_OBJCOPY_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$OBJCOPY_FOR_TARGET"; then
-  ac_cv_prog_OBJCOPY_FOR_TARGET="$OBJCOPY_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $OBJCOPY_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_OBJCOPY_FOR_TARGET="$OBJCOPY_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_OBJCOPY_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_OBJCOPY_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12294,9 +12398,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-OBJCOPY_FOR_TARGET=$ac_cv_prog_OBJCOPY_FOR_TARGET
+OBJCOPY_FOR_TARGET=$ac_cv_path_OBJCOPY_FOR_TARGET
 if test -n "$OBJCOPY_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY_FOR_TARGET" >&5
 $as_echo "$OBJCOPY_FOR_TARGET" >&6; }
@@ -12307,25 +12412,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_OBJCOPY_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_OBJCOPY_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_OBJCOPY_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_OBJCOPY_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$OBJCOPY_FOR_TARGET"; then
-  ac_cv_prog_OBJCOPY_FOR_TARGET="$OBJCOPY_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $OBJCOPY_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_OBJCOPY_FOR_TARGET="$OBJCOPY_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_OBJCOPY_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_OBJCOPY_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12333,9 +12440,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-OBJCOPY_FOR_TARGET=$ac_cv_prog_OBJCOPY_FOR_TARGET
+OBJCOPY_FOR_TARGET=$ac_cv_path_OBJCOPY_FOR_TARGET
 if test -n "$OBJCOPY_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY_FOR_TARGET" >&5
 $as_echo "$OBJCOPY_FOR_TARGET" >&6; }
@@ -12346,11 +12454,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_OBJCOPY_FOR_TARGET" && break
+    test -n "$ac_cv_path_OBJCOPY_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_OBJCOPY_FOR_TARGET" ; then
+if test -z "$ac_cv_path_OBJCOPY_FOR_TARGET" ; then
   set dummy objcopy
   if test $build = $target ; then
     OBJCOPY_FOR_TARGET="$2"
@@ -12358,7 +12466,7 @@  if test -z "$ac_cv_prog_OBJCOPY_FOR_TARGET" ; then
     OBJCOPY_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  OBJCOPY_FOR_TARGET="$ac_cv_prog_OBJCOPY_FOR_TARGET"
+  OBJCOPY_FOR_TARGET="$ac_cv_path_OBJCOPY_FOR_TARGET"
 fi
 
 else
@@ -12433,31 +12541,33 @@  if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
 
 
 if test -n "$OBJDUMP_FOR_TARGET"; then
-  ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
-elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
-  OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
+  ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
+elif test -n "$ac_cv_path_OBJDUMP_FOR_TARGET"; then
+  OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
+if test -n "$ac_cv_path_OBJDUMP_FOR_TARGET"; then
   for ncn_progname in objdump; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$OBJDUMP_FOR_TARGET"; then
-  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $OBJDUMP_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12465,9 +12575,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
+OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
 if test -n "$OBJDUMP_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP_FOR_TARGET" >&5
 $as_echo "$OBJDUMP_FOR_TARGET" >&6; }
@@ -12480,12 +12591,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in objdump; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -12496,27 +12607,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
+if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET"; then
   for ncn_progname in objdump; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$OBJDUMP_FOR_TARGET"; then
-  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $OBJDUMP_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12524,9 +12637,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
+OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
 if test -n "$OBJDUMP_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP_FOR_TARGET" >&5
 $as_echo "$OBJDUMP_FOR_TARGET" >&6; }
@@ -12537,25 +12651,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$OBJDUMP_FOR_TARGET"; then
-  ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $OBJDUMP_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12563,9 +12679,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
+OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
 if test -n "$OBJDUMP_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP_FOR_TARGET" >&5
 $as_echo "$OBJDUMP_FOR_TARGET" >&6; }
@@ -12576,11 +12693,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
+    test -n "$ac_cv_path_OBJDUMP_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
+if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
   set dummy objdump
   if test $build = $target ; then
     OBJDUMP_FOR_TARGET="$2"
@@ -12588,7 +12705,7 @@  if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
+  OBJDUMP_FOR_TARGET="$ac_cv_path_OBJDUMP_FOR_TARGET"
 fi
 
 else
@@ -12663,31 +12780,33 @@  if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
 
 
 if test -n "$RANLIB_FOR_TARGET"; then
-  ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
-elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
-  RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
+  ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
+elif test -n "$ac_cv_path_RANLIB_FOR_TARGET"; then
+  RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
+if test -n "$ac_cv_path_RANLIB_FOR_TARGET"; then
   for ncn_progname in ranlib; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$RANLIB_FOR_TARGET"; then
-  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $RANLIB_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12695,9 +12814,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
+RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
 if test -n "$RANLIB_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB_FOR_TARGET" >&5
 $as_echo "$RANLIB_FOR_TARGET" >&6; }
@@ -12710,12 +12830,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in ranlib; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -12726,27 +12846,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
+if test -z "$ac_cv_path_RANLIB_FOR_TARGET"; then
   for ncn_progname in ranlib; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$RANLIB_FOR_TARGET"; then
-  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $RANLIB_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12754,9 +12876,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
+RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
 if test -n "$RANLIB_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB_FOR_TARGET" >&5
 $as_echo "$RANLIB_FOR_TARGET" >&6; }
@@ -12767,25 +12890,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$RANLIB_FOR_TARGET"; then
-  ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $RANLIB_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12793,9 +12918,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
+RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
 if test -n "$RANLIB_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB_FOR_TARGET" >&5
 $as_echo "$RANLIB_FOR_TARGET" >&6; }
@@ -12806,11 +12932,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
+    test -n "$ac_cv_path_RANLIB_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
+if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
   set dummy ranlib
   if test $build = $target ; then
     RANLIB_FOR_TARGET="$2"
@@ -12818,7 +12944,7 @@  if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
+  RANLIB_FOR_TARGET="$ac_cv_path_RANLIB_FOR_TARGET"
 fi
 
 else
@@ -12893,31 +13019,33 @@  if test -z "$ac_cv_path_READELF_FOR_TARGET" ; then
 
 
 if test -n "$READELF_FOR_TARGET"; then
-  ac_cv_prog_READELF_FOR_TARGET=$READELF_FOR_TARGET
-elif test -n "$ac_cv_prog_READELF_FOR_TARGET"; then
-  READELF_FOR_TARGET=$ac_cv_prog_READELF_FOR_TARGET
+  ac_cv_path_READELF_FOR_TARGET=$READELF_FOR_TARGET
+elif test -n "$ac_cv_path_READELF_FOR_TARGET"; then
+  READELF_FOR_TARGET=$ac_cv_path_READELF_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_READELF_FOR_TARGET"; then
+if test -n "$ac_cv_path_READELF_FOR_TARGET"; then
   for ncn_progname in readelf; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_READELF_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_READELF_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$READELF_FOR_TARGET"; then
-  ac_cv_prog_READELF_FOR_TARGET="$READELF_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $READELF_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_READELF_FOR_TARGET="$READELF_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_READELF_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_READELF_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12925,9 +13053,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-READELF_FOR_TARGET=$ac_cv_prog_READELF_FOR_TARGET
+READELF_FOR_TARGET=$ac_cv_path_READELF_FOR_TARGET
 if test -n "$READELF_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF_FOR_TARGET" >&5
 $as_echo "$READELF_FOR_TARGET" >&6; }
@@ -12940,12 +13069,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_READELF_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_READELF_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in readelf; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_READELF_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_READELF_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -12956,27 +13085,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_READELF_FOR_TARGET"; then
+if test -z "$ac_cv_path_READELF_FOR_TARGET"; then
   for ncn_progname in readelf; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_READELF_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_READELF_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$READELF_FOR_TARGET"; then
-  ac_cv_prog_READELF_FOR_TARGET="$READELF_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $READELF_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_READELF_FOR_TARGET="$READELF_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_READELF_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_READELF_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -12984,9 +13115,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-READELF_FOR_TARGET=$ac_cv_prog_READELF_FOR_TARGET
+READELF_FOR_TARGET=$ac_cv_path_READELF_FOR_TARGET
 if test -n "$READELF_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF_FOR_TARGET" >&5
 $as_echo "$READELF_FOR_TARGET" >&6; }
@@ -12997,25 +13129,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_READELF_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_READELF_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_READELF_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_READELF_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$READELF_FOR_TARGET"; then
-  ac_cv_prog_READELF_FOR_TARGET="$READELF_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $READELF_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_READELF_FOR_TARGET="$READELF_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_READELF_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_READELF_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13023,9 +13157,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-READELF_FOR_TARGET=$ac_cv_prog_READELF_FOR_TARGET
+READELF_FOR_TARGET=$ac_cv_path_READELF_FOR_TARGET
 if test -n "$READELF_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF_FOR_TARGET" >&5
 $as_echo "$READELF_FOR_TARGET" >&6; }
@@ -13036,11 +13171,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_READELF_FOR_TARGET" && break
+    test -n "$ac_cv_path_READELF_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_READELF_FOR_TARGET" ; then
+if test -z "$ac_cv_path_READELF_FOR_TARGET" ; then
   set dummy readelf
   if test $build = $target ; then
     READELF_FOR_TARGET="$2"
@@ -13048,7 +13183,7 @@  if test -z "$ac_cv_prog_READELF_FOR_TARGET" ; then
     READELF_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  READELF_FOR_TARGET="$ac_cv_prog_READELF_FOR_TARGET"
+  READELF_FOR_TARGET="$ac_cv_path_READELF_FOR_TARGET"
 fi
 
 else
@@ -13123,31 +13258,33 @@  if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
 
 
 if test -n "$STRIP_FOR_TARGET"; then
-  ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
-elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
-  STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
+  ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
+elif test -n "$ac_cv_path_STRIP_FOR_TARGET"; then
+  STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
+if test -n "$ac_cv_path_STRIP_FOR_TARGET"; then
   for ncn_progname in strip; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$STRIP_FOR_TARGET"; then
-  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $STRIP_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13155,9 +13292,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
+STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
 if test -n "$STRIP_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP_FOR_TARGET" >&5
 $as_echo "$STRIP_FOR_TARGET" >&6; }
@@ -13170,12 +13308,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in strip; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -13186,27 +13324,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
+if test -z "$ac_cv_path_STRIP_FOR_TARGET"; then
   for ncn_progname in strip; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$STRIP_FOR_TARGET"; then
-  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $STRIP_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13214,9 +13354,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
+STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
 if test -n "$STRIP_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP_FOR_TARGET" >&5
 $as_echo "$STRIP_FOR_TARGET" >&6; }
@@ -13227,25 +13368,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$STRIP_FOR_TARGET"; then
-  ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $STRIP_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13253,9 +13396,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
+STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
 if test -n "$STRIP_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP_FOR_TARGET" >&5
 $as_echo "$STRIP_FOR_TARGET" >&6; }
@@ -13266,11 +13410,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
+    test -n "$ac_cv_path_STRIP_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
+if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
   set dummy strip
   if test $build = $target ; then
     STRIP_FOR_TARGET="$2"
@@ -13278,7 +13422,7 @@  if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
+  STRIP_FOR_TARGET="$ac_cv_path_STRIP_FOR_TARGET"
 fi
 
 else
@@ -13353,31 +13497,33 @@  if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
 
 
 if test -n "$WINDRES_FOR_TARGET"; then
-  ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
-elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
-  WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
+  ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
+elif test -n "$ac_cv_path_WINDRES_FOR_TARGET"; then
+  WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
+if test -n "$ac_cv_path_WINDRES_FOR_TARGET"; then
   for ncn_progname in windres; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$WINDRES_FOR_TARGET"; then
-  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $WINDRES_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13385,9 +13531,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
+WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
 if test -n "$WINDRES_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINDRES_FOR_TARGET" >&5
 $as_echo "$WINDRES_FOR_TARGET" >&6; }
@@ -13400,12 +13547,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in windres; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -13416,27 +13563,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
+if test -z "$ac_cv_path_WINDRES_FOR_TARGET"; then
   for ncn_progname in windres; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$WINDRES_FOR_TARGET"; then
-  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $WINDRES_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13444,9 +13593,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
+WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
 if test -n "$WINDRES_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINDRES_FOR_TARGET" >&5
 $as_echo "$WINDRES_FOR_TARGET" >&6; }
@@ -13457,25 +13607,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$WINDRES_FOR_TARGET"; then
-  ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $WINDRES_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13483,9 +13635,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
+WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
 if test -n "$WINDRES_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINDRES_FOR_TARGET" >&5
 $as_echo "$WINDRES_FOR_TARGET" >&6; }
@@ -13496,11 +13649,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
+    test -n "$ac_cv_path_WINDRES_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
+if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
   set dummy windres
   if test $build = $target ; then
     WINDRES_FOR_TARGET="$2"
@@ -13508,7 +13661,7 @@  if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
+  WINDRES_FOR_TARGET="$ac_cv_path_WINDRES_FOR_TARGET"
 fi
 
 else
@@ -13583,31 +13736,33 @@  if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
 
 
 if test -n "$WINDMC_FOR_TARGET"; then
-  ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
-elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
-  WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
+  ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
+elif test -n "$ac_cv_path_WINDMC_FOR_TARGET"; then
+  WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
 fi
 
-if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
+if test -n "$ac_cv_path_WINDMC_FOR_TARGET"; then
   for ncn_progname in windmc; do
     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$WINDMC_FOR_TARGET"; then
-  ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $WINDMC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13615,9 +13770,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
+WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
 if test -n "$WINDMC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINDMC_FOR_TARGET" >&5
 $as_echo "$WINDMC_FOR_TARGET" >&6; }
@@ -13630,12 +13786,12 @@  fi
   done
 fi
 
-if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
+if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
   for ncn_progname in windmc; do
     { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ncn_progname} in $with_build_time_tools" >&5
 $as_echo_n "checking for ${ncn_progname} in $with_build_time_tools... " >&6; }
     if test -x $with_build_time_tools/${ncn_progname}; then
-      ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
+      ac_cv_path_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
       { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
 $as_echo "yes" >&6; }
       break
@@ -13646,27 +13802,29 @@  $as_echo "no" >&6; }
   done
 fi
 
-if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
+if test -z "$ac_cv_path_WINDMC_FOR_TARGET"; then
   for ncn_progname in windmc; do
     if test -n "$ncn_target_tool_prefix"; then
       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$WINDMC_FOR_TARGET"; then
-  ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $WINDMC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
+    ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13674,9 +13832,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
+WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
 if test -n "$WINDMC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINDMC_FOR_TARGET" >&5
 $as_echo "$WINDMC_FOR_TARGET" >&6; }
@@ -13687,25 +13846,27 @@  fi
 
 
     fi
-    if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
+    if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test $build = $target ; then
       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
 set dummy ${ncn_progname}; ac_word=$2
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
 $as_echo_n "checking for $ac_word... " >&6; }
-if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then :
+if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then :
   $as_echo_n "(cached) " >&6
 else
-  if test -n "$WINDMC_FOR_TARGET"; then
-  ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+  case $WINDMC_FOR_TARGET in
+  [\\/]* | ?:[\\/]*)
+  ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 for as_dir in $PATH
 do
   IFS=$as_save_IFS
   test -z "$as_dir" && as_dir=.
     for ac_exec_ext in '' $ac_executable_extensions; do
   if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
-    ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
+    ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
     $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
     break 2
   fi
@@ -13713,9 +13874,10 @@  done
   done
 IFS=$as_save_IFS
 
+  ;;
+esac
 fi
-fi
-WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
+WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
 if test -n "$WINDMC_FOR_TARGET"; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WINDMC_FOR_TARGET" >&5
 $as_echo "$WINDMC_FOR_TARGET" >&6; }
@@ -13726,11 +13888,11 @@  fi
 
 
     fi
-    test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
+    test -n "$ac_cv_path_WINDMC_FOR_TARGET" && break
   done
 fi
 
-if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
+if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
   set dummy windmc
   if test $build = $target ; then
     WINDMC_FOR_TARGET="$2"
@@ -13738,7 +13900,7 @@  if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
   fi
 else
-  WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
+  WINDMC_FOR_TARGET="$ac_cv_path_WINDMC_FOR_TARGET"
 fi
 
 else
diff --git a/configure.ac b/configure.ac
index 0cf052b..a5b2fcd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -3371,11 +3371,11 @@  AC_ARG_WITH([build-time-tools],
    esac],
   [with_build_time_tools=])
 
-NCN_STRICT_CHECK_TARGET_TOOLS(CC_FOR_TARGET, cc gcc)
-NCN_STRICT_CHECK_TARGET_TOOLS(CXX_FOR_TARGET, c++ g++ cxx gxx)
-NCN_STRICT_CHECK_TARGET_TOOLS(GCC_FOR_TARGET, gcc, ${CC_FOR_TARGET})
-NCN_STRICT_CHECK_TARGET_TOOLS(GFORTRAN_FOR_TARGET, gfortran)
-NCN_STRICT_CHECK_TARGET_TOOLS(GOC_FOR_TARGET, gccgo)
+NCN_STRICT_PATH_TARGET_TOOLS(CC_FOR_TARGET, cc gcc)
+NCN_STRICT_PATH_TARGET_TOOLS(CXX_FOR_TARGET, c++ g++ cxx gxx)
+NCN_STRICT_PATH_TARGET_TOOLS(GCC_FOR_TARGET, gcc, ${CC_FOR_TARGET})
+NCN_STRICT_PATH_TARGET_TOOLS(GFORTRAN_FOR_TARGET, gfortran)
+NCN_STRICT_PATH_TARGET_TOOLS(GOC_FOR_TARGET, gccgo)
 
 ACX_CHECK_INSTALLED_TARGET_TOOL(AR_FOR_TARGET, ar)
 ACX_CHECK_INSTALLED_TARGET_TOOL(AS_FOR_TARGET, as)