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)