diff --git a/gdb/testsuite/gdb.multi/multi-arch-exec.exp b/gdb/testsuite/gdb.multi/multi-arch-exec.exp
index 3196cf3..53e1280 100644
--- a/gdb/testsuite/gdb.multi/multi-arch-exec.exp
+++ b/gdb/testsuite/gdb.multi/multi-arch-exec.exp
@@ -29,57 +29,126 @@ if [istarget "i?86-*linux*"] {
     return
 }
 
-# Can't use standard_testfile, we want executables with specialized
-# names.
-set exec1 "multi-arch-exec"
-set srcfile1 multi-arch-exec.c
-set binfile1 [standard_output_file ${exec1}]
-
-set exec2 "multi-arch-exec-hello"
-set srcfile2 hello.c
-set binfile2 [standard_output_file ${exec2}]
-
-# Build two executables, one for each arch.
-
-if [istarget "s390*-*-*"] {
-    set march1 "-m64"
-    set march2 "-m31"
-} elseif { [istarget "aarch64*-*-*"] } {
-    set march1 ""
-    set march2 ""
-} else {
-    set march1 "-m64"
-    set march2 "-m32"
+# The testcase builds two programs, each of its own architecture.  For
+# example, one built with -m64, another with -m32.  The exact compiler
+# options depends on target triplet.  We generically refer to the
+# architectures simply as 'architecture 1' and 'architecture 2'.  Each
+# program is actually built twice, once for each architecture, because
+# we test both execing from arch1 to arch2 and from arch2 to arch1.
+# The architecture of the executable that execs is encoded in the
+# binaries' names, like so:
+#
+#    $first_arch-multi-arch-exec         # execing program
+#    $first_arch-multi-arch-exec-hello   # execed program
+
+# Append the options necessary to build a program for architecture 1
+# to the OPTIONS_VAR list.
+
+proc append_arch1_options {options_var} {
+    upvar 1 $options_var options
+
+    if { [istarget "aarch64*-*-*"] } {
+	return 1
+    }
+
+    lappend options "additional_flags=-m64"
+    return 1
 }
 
-if { [prepare_for_testing "failed to prepare" ${exec1} "${srcfile1}" \
-	  [list debug pthreads \
-	       additional_flags=${march1}]] } {
-    return -1
+# Append the options necessary to build a program for architecture 2
+# to the OPTIONS_VAR list.
+
+proc append_arch2_options {options_var} {
+    upvar 1 $options_var options
+
+    if { [istarget "aarch64*-*-*"] } {
+	if {[info exists ARM_CC_FOR_TARGET]} {
+	    lappend options "compiler=${ARM_CC_FOR_TARGET}"
+	    return 1
+	} else {
+	    unsupported "ARM compiler is not known"
+	    return 0
+	}
+    }
+
+    if [istarget "s390*-*-*"] {
+	set march "-m31"
+    } else {
+	set march "-m32"
+    }
+    lappend options "additional_flags=${march}"
+    return 1
 }
 
-set options [list debug]
+# Append the options necessary to build a program for architecture
+# ARCH to the OPTIONS_VAR list.  Returns true on success.
 
-if { [istarget "aarch64*-*-*"] } {
-    if {[info exists ARM_CC_FOR_TARGET]} {
-	lappend options "compiler=${ARM_CC_FOR_TARGET}"
+proc append_arch_options {arch options_var} {
+    upvar 1 $options_var options
+
+    if {$arch == 1} {
+	return [append_arch1_options options]
+    } elseif {$arch == 2} {
+	return [append_arch2_options options]
     } else {
-	unsupported "ARM compiler is not known"
-	return -1
+	error "unhandled architecture: $arch"
     }
-} else {
-    lappend options "additional_flags=${march2}"
 }
 
-if { [prepare_for_testing "failed to prepare" ${exec2} "${srcfile2}" \
-	  $options] } {
-    return -1
+# Build the executables for testing with FIRST_ARCH (either 1 or 2) as
+# the architecture before the exec.  Returns true on success.
+
+proc build_executables { first_arch } {
+
+    # Can't use standard_testfile, we want executables with specialized
+    # names.
+    set from_exec "$first_arch-multi-arch-exec"
+    set from_srcfile multi-arch-exec.c
+    set from_binfile [standard_output_file ${from_exec}]
+
+    set to_exec "$first_arch-multi-arch-exec-hello"
+    set to_srcfile hello.c
+    set to_binfile [standard_output_file ${to_exec}]
+
+    # Build two executables, one for each arch.
+
+    if {$first_arch == 1} {
+	set from_arch 1
+	set to_arch 2
+    } elseif {$first_arch == 2} {
+	set from_arch 2
+	set to_arch 1
+    } else {
+	error "unhandled first architecture: $first_arch"
+    }
+
+    set from_options [list debug pthreads]
+    if {![append_arch_options $from_arch from_options]} {
+	return 0
+    }
+
+    if { [build_executable "failed to prepare" ${from_exec} "${from_srcfile}" \
+	      $from_options] } {
+	return 0
+    }
+
+    set to_options [list debug]
+    if {![append_arch_options $to_arch to_options]} {
+	return 0
+    }
+
+    if { [build_executable "failed to prepare" ${to_exec} "${to_srcfile}" \
+	      $to_options] } {
+	return 0
+    }
+
+    return 1
 }
 
-proc do_test { mode selected_thread } {
-	global exec1
+proc do_test { first_arch mode selected_thread } {
+	set from_exec "$first_arch-multi-arch-exec"
 
-	clean_restart ${exec1}
+	clean_restart ${from_exec}
 	if ![runto all_started] then {
 	    fail "couldn't run to all_started"
 	    return -1
@@ -102,12 +171,19 @@ proc do_test { mode selected_thread } {
 	gdb_test "continue" "Breakpoint 2, main.*" "continue across exec that changes architecture"
 }
 
-# Test handling the exec event with either the main thread or the
-# second thread selected.  This tries to ensure that GDB doesn't read
-# registers off of the execing thread before figuring out its
-# architecture.
-foreach_with_prefix selected_thread {1 2} {
-    foreach_with_prefix follow_exec_mode {"same" "new"} {
-	do_test $follow_exec_mode $selected_thread
+# Test both arch1=>arch2 and arch2=>arch1.
+foreach_with_prefix first_arch {1 2} {
+    if {![build_executables $first_arch]} {
+	continue
+    }
+
+    # Test handling the exec event with either the main thread or the
+    # second thread selected.  This tries to ensure that GDB doesn't read
+    # registers off of the execing thread before figuring out its
+    # architecture.
+    foreach_with_prefix selected_thread {1 2} {
+	foreach_with_prefix follow_exec_mode {"same" "new"} {
+	    do_test $first_arch $follow_exec_mode $selected_thread
+	}
     }
 }
