pax_global_header00006660000000000000000000000064130175547470014527gustar00rootroot0000000000000052 comment=4548fc2198e7e5168f0d9d14afb1da45c6cd680f arch-test-0.7/000077500000000000000000000000001301755474700132675ustar00rootroot00000000000000arch-test-0.7/.gitignore000066400000000000000000000000371301755474700152570ustar00rootroot00000000000000*~ *.o arch-test-* core config arch-test-0.7/LICENSE000066400000000000000000000020001301755474700142640ustar00rootroot00000000000000Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. arch-test-0.7/Makefile000066400000000000000000000100301301755474700147210ustar00rootroot00000000000000ARCHS=amd64 x32 i386 \ win32 win64 \ mips mipsel mipsn32 mipsn32el mips64 mips64el \ illumos-amd64 \ kfreebsd-amd64 kfreebsd-i386 \ powerpc ppc64 ppc64el powerpcspe \ s390x \ arm64 arm64ilp32 \ arm armel armhf \ sh4 \ m68k \ sparc sparc64 \ alpha \ hppa \ X86=x86_64-linux-gnu MIPS=mips-linux-gnu POWERPC=powerpc-linux-gnu ARM=arm-linux-gnueabihf SPARC=sparc64-linux-gnu -include config all: $(ARCHS:%=arch-test-%) clean: rm -f *.o arch-test-* core *.core distclean: clean rm -f config DESTDIR= PREFIX=/usr/local install: all mkdir -p $(DESTDIR)$(PREFIX)/lib/arch-test/ sed -e "s|^HELPERS.*|HELPERS=$(PREFIX)/lib/arch-test/|" \ $(DESTDIR)$(PREFIX)/bin/arch-test chmod a+x $(DESTDIR)$(PREFIX)/bin/arch-test for x in $(ARCHS); do cp -p arch-test-$$x \ $(DESTDIR)$(PREFIX)/lib/arch-test/$$x;done mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1/ install -p *.1 $(DESTDIR)$(PREFIX)/share/man/man1/ arch-test-amd64: amd64.s $(X86)-as --64 $^ -o amd64.o $(X86)-ld -melf_x86_64 -s amd64.o -o $@ arch-test-x32: x32.s $(X86)-as --x32 $^ -o x32.o $(X86)-ld -melf32_x86_64 -s x32.o -o $@ arch-test-i386: i386.s $(X86)-as --32 $^ -o i386.o $(X86)-ld -melf_i386 -s i386.o -o $@ arch-test-win32: generic.c i686-w64-mingw32-gcc $^ -s -o $@ arch-test-win64: generic.c x86_64-w64-mingw32-gcc $^ -s -o $@ arch-test-mips: mips.s $(MIPS)-as -32 -EB $^ -o mips.o $(MIPS)-ld -melf32btsmip -s mips.o -o $@ arch-test-mipsel: mips.s $(MIPS)-as -32 -EL $^ -o mipsel.o $(MIPS)-ld -melf32ltsmip -s mipsel.o -o $@ arch-test-mipsn32: mipsn32.s $(MIPS)-as -n32 -EB $^ -o mipsn32.o $(MIPS)-ld -melf32btsmipn32 -s mipsn32.o -o $@ arch-test-mipsn32el: mipsn32.s $(MIPS)-as -n32 -EL $^ -o mipsn32el.o $(MIPS)-ld -melf32ltsmipn32 -s mipsn32el.o -o $@ arch-test-mips64: mips64.s $(MIPS)-as -64 -EB $^ -o mips64.o $(MIPS)-ld -melf64btsmip -s mips64.o -o $@ arch-test-mips64el: mips64.s $(MIPS)-as -64 -EL $^ -o mips64el.o $(MIPS)-ld -melf64ltsmip -s mips64el.o -o $@ arch-test-illumos-amd64: solaris-amd64.s $(X86)-as --64 $^ -o illumos-amd64.o $(X86)-ld -melf_x86_64 -s illumos-amd64.o -o $@ arch-test-kfreebsd-amd64: solaris-amd64.s $(X86)-as --64 $^ -o kfreebsd-amd64.o $(X86)-ld -melf_x86_64 -s kfreebsd-amd64.o -o $@ printf '\t'|dd of=$@ bs=1 count=1 seek=7 conv=notrunc arch-test-kfreebsd-i386: kfreebsd-i386.s $(X86)-as --32 $^ -o kfreebsd-i386.o $(X86)-ld -melf_i386 -s kfreebsd-i386.o -o $@ printf '\t'|dd of=$@ bs=1 count=1 seek=7 conv=notrunc arch-test-powerpc: powerpc.s $(POWERPC)-as -a32 $^ -o powerpc.o $(POWERPC)-ld -melf32ppc -s powerpc.o -o $@ arch-test-ppc64: ppc64.s $(POWERPC)-as -a64 $^ -o ppc64.o $(POWERPC)-ld -melf64ppc -s ppc64.o -o $@ arch-test-ppc64el: ppc64el.s powerpc64le-linux-gnu-as -mpower8 $^ -o ppc64el.o powerpc64le-linux-gnu-ld -s ppc64el.o -o $@ arch-test-powerpcspe: powerpcspe.s $(POWERPC)-as -a32 -me500 $^ -o powerpcspe.o $(POWERPC)-ld -melf32ppc -s powerpcspe.o -o $@ arch-test-s390x: s390x.s s390x-linux-gnu-as $^ -o s390x.o s390x-linux-gnu-ld -s s390x.o -o $@ arch-test-arm64: arm64.s aarch64-linux-gnu-as $^ -o arm64.o aarch64-linux-gnu-ld -s arm64.o -o $@ arch-test-arm64ilp32: arm64.s aarch64-linux-gnu-as -mabi=ilp32 $^ -o arm64ilp32.o aarch64-linux-gnu-ld -maarch64linux32 -s arm64ilp32.o -o $@ arch-test-arm: arm.oabi.s $(ARM)-as $^ -o arm.o $(ARM)-ld -s arm.o -o $@ arch-test-armel: arm.eabi.s $(ARM)-as $^ -o armel.o $(ARM)-ld -s armel.o -o $@ arch-test-armhf: armhf.s $(ARM)-as $^ -o armhf.o $(ARM)-ld -s armhf.o -o $@ arch-test-sh4: sh4.s sh4-linux-gnu-as $^ -o sh4.o sh4-linux-gnu-ld -s sh4.o -o $@ arch-test-m68k: m68k.s m68k-linux-gnu-as $^ -o m68k.o m68k-linux-gnu-ld -s m68k.o -o $@ arch-test-sparc64: sparc64.s $(SPARC)-as --64 $^ -o sparc64.o $(SPARC)-ld -melf64_sparc -s sparc64.o -o $@ arch-test-sparc: sparc.s $(SPARC)-as --32 $^ -o sparc.o $(SPARC)-ld -melf32_sparc -s sparc.o -o $@ arch-test-alpha: alpha.s alpha-linux-gnu-as $^ -o alpha.o alpha-linux-gnu-ld -s alpha.o -o $@ arch-test-hppa: hppa.s hppa-linux-gnu-as $^ -o hppa.o hppa-linux-gnu-ld -s hppa.o -o $@ arch-test-0.7/README000066400000000000000000000060671301755474700141600ustar00rootroot00000000000000This tool will tell you "can your machine+kernel run architecture X?". The check is for the ability to run machine code and supporting appropriate syscall ABI, not for the presence of userland libraries. Ie, a positive answer means you can use a chroot or container of that architecture, add it to your multiarch set, etc, but doesn't mean you can currently run non-static binaries without installing required libraries. Architectures detected by this version of arch-test are: * amd64, i386, x32 * mips, mipsel, mipsn32, mipsn32el, mips64, mips64el * arm, armel, armhf, arm64, arm64ilp32 * powerpc, ppc64, ppc64el, powerpcspe * m68k * sh4 * s390x * sparc, sparc64 * illumos-amd64 * win32, win64 * kfreebsd-amd64, kfreebsd-i386 * alpha * hppa Detection quirks ================ This tool claims FreeBSD with its Linux emulation layer on can't run i386. That's not a bug -- it can't run _unmodified_ i386 binaries. There's a tool "brandelf" that sets field 0x7 in the ELF header, required by FreeBSD but not set by Linux nor Solaris toolchains. Emulation of the SWP instruction on at least Odroid-U2 vendor kernel is broken, subtly breaking armel processes. They mostly work but once there's lock contention, shit will happen. Thus, it's debatable whether to mark armel as unsupported there -- I do so only because it's easier for me. Adding new archs ================ Helper programs are supposed to write the string "ok\n" to stdout then return exit code 0. This can be done by statically compiling "generic.c" for the given architecture. Unfortunately, doing so with glibc produces ~800KB executables which multiplied by the number of archs to test would take too much space for such a minor tool. And, for non-baseline archs some specific code is needed. Examples: * ppc64el requires POWER8, some versions of qemu-user can run little-endian PPC64 but lack some instructions required by the Debian arch. * powerpcspe has no classic FPU but a bunch of other instructions. * armhf uses same syscall ABI as armel. One way to ascertain required support is trying to run an unprivileged instruction that's lacking on older versions of the ISA. This causes the helper program to fail with SIGILL/SIGFPE/etc which means it will return an exit code other than 0. Missing Debian architectures ============================ * hurd-*: it has no proper syscalls, the equivalent being complicated RPC calls implemented inside glibc. This is similar to Windows where the real syscalls (NT) are undocumented and unstable while everyone is supposed to link to "kernel" shared libraries. Unfortunately for hurd, there's no cross toolchain in Debian, unlike mingw. * ia64: no cross binutils Non-Debian architectures ======================== While currently arch-test is heavily biased towards Debian, there is no reason for it to stay so. I would need to compile the assembler from source during the build, but that's doable. All that's needed is motivation (ie, tell me if you have an use) and access to test machines. Resources ========= man 2 syscall https://github.com/deater/ll_asm.git arch-test-0.7/alpha.s000066400000000000000000000002571301755474700145440ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: br $27, 0 ldgp $gp, 0($27) ldil $0, 4 ldil $16, 1 lda $17, msg ldil $18, 3 callsys clr $16 ldil $0, 1 callsys arch-test-0.7/amd64.s000066400000000000000000000003271301755474700143700ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov $1, %rax # syscall: write(rdi, rsi, rdx) mov $1, %rdi mov $msg, %rsi mov $3, %rdx syscall mov $60, %rax # syscall: _exit(rdi) xor %rdi, %rdi syscall arch-test-0.7/arch-test000077500000000000000000000015531301755474700151130ustar00rootroot00000000000000#!/bin/bash # Need bash not dash because of https://bugs.debian.org/816313 # Near-misses fail with SIGILL or SIGSEGV, we don't want core dumps. ulimit -c 0 HELPERS=$0- if [ "x$1" = "x-n" ] then export QEMU_VERSION=meow WINEPREFIX=/dev/null shift fi if [ $# -gt 1 ] then echo >&2 'Usage: "arch-test [-n]" or "arch-test [-n] ".'; exit 1 fi if [ $# -eq 1 ] then if [ ! -x "$HELPERS$1" ] then echo "I don't know how to detect arch '$1', sorry."; exit 2 fi MSG=`"$HELPERS$1" 2>/dev/null` if [ $? -eq 0 -a "x$MSG" = "xok" ] then echo "$1: ok"; exit 0 else echo "$1: not supported on this machine/kernel"; exit 1 fi fi for x in $HELPERS* do ARCH="$(basename "$x")" ARCH="${ARCH##arch-test-}" MSG=`"$x" 2>/dev/null|tr -d '\r'` if [ $? -eq 0 -a "x$MSG" = "xok" ] then echo "$ARCH" fi done arch-test-0.7/arch-test.1000066400000000000000000000046751301755474700152570ustar00rootroot00000000000000.TH arch-test 1 .SH NAME arch-test \- detect architectures your kernel can run binaries of .SH SYNOPSIS .TP .BR arch-test " [" -n ] enumerates the architectures .TP .BR arch-test " [" -n ] " " "\fI\fR" tests a single arch .SH DESCRIPTION When called without an argument, \fBarch-test\fR outputs the list of architectures executable by your running kernel, one per line, using Debian arch names. \fILibc\fR or other libraries are neither needed nor checked \&\(em an arch is listed if its machine code can be executed and the appropriate syscall ABI is supported by the kernel. This means, you can run these architectures in a \fIchroot\fR or a container, execute them using multiarch, run static binaries, etc. The ability to run additional architectures can be gained via \fIbinfmt\fRs on Linux, Linux emulation on BSD, etc. An architecture is considered runnable only if your kernel can run \fIunmodified\fR binaries, without extra steps such as recompiling (Raspbian armhf) or using \fBbrandelf\fR on binaries you'd want to run (FreeBSD emulation of Linux). Also, as Debian requires 686 on i386 as of the stretch release, 686 support is checked for. If \fB-n\fR is specified, \fBarch-test\fR will try to disable known emulators (currently \fBqemu\fR and \fBwine\fR). Note that a whole-machine emulator appears to be native as far as the kernel is concerned. When called with an arch name as an argument, \fBarch-test\fR tests the specified architecture. A human-friendly message will be printed, and the exit code can be: .TP .B 0 congratulations, the arch can be run on your kernel .TP .B 1 failure .TP .B 2 cannot check \(em \fBarch-test\fR lacks a helper for this arch .TP (Shell hint: with \fIset -e\fR you write: \fIret=0; arch-test $ARCH || ret=$?\fR) .SS "Helper programs" The detection is done by small programs located in \fI/usr/lib/arch-test/\fR. These programs check whether the running kernel can execute binaries of a given architecture. When run, if successful, each such program prints \fI"ok"\fR on stdout and returns exit code 0. When the check fails, these helper programs may die horribly \(em always with a non-zero exit code. Usually the kernel will notice the incompatibility and nicely abort the attempt, but in some near-miss cases the failure is more messy, such as \fISIGILL\fR or \fISIGSEGV\fR. If you want to run the helpers directly, you'd want to redirect \fIstderr\fR to \&\fI/dev/null\fR and to disable core dumps (\fBulimit -c 0\fR). arch-test-0.7/arm.eabi.s000066400000000000000000000005071301755474700151330ustar00rootroot00000000000000.globl _start .data msg: .ascii "nk\n" // first byte later amended to 'o' .text _start: ldr r1, =msg mov r0, #0x6f // 'o' swpb r0, r0, [r1] // SIGILL on some arm64 without CONFIG_ARMV8_DEPRECATED mov r0, #1 mov r2, #3 mov r7, #4 // syscall: write(r0, r1, r2) swi 0 mov r0, #0 mov r7, #1 // syscall: _exit(r0) swi 0 arch-test-0.7/arm.oabi.s000066400000000000000000000002701301755474700151420ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov a1, #1 ldr a2, =msg mov a3, #3 swi 0x900004 // syscall: write(a1, a2, a3) mov a1, #0 swi 0x900001 // syscall: _exit(a1) arch-test-0.7/arm64.s000066400000000000000000000003031301755474700144000ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov x0, #1 adr x1, msg mov x2, #3 mov x8, 64 // syscall: write(x0, x1, x2) svc 0 mov x0, #0 mov x8, 93 // syscall: _exit(x0) svc 0 arch-test-0.7/armhf.s000066400000000000000000000003461301755474700145530ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: dmb // SIGILL on CPUs below ARMv7 mov r0, #1 ldr r1, =msg mov r2, #3 mov r7, #4 // syscall: write(r0, r1, r2) swi 0 mov r0, #0 mov r7, #1 // syscall: _exit(r0) swi 0 arch-test-0.7/configure000077500000000000000000000025531301755474700152030ustar00rootroot00000000000000#!/usr/bin/perl -w open MAKEFILE, "} close MAKEFILE; /^ARCHS=((?:[a-z0-9-]| |\t|\\\n)*)/m or die "Couldn't parse ARCHS= in the Makefile\n"; $ARCH{$_}=1 for($1=~/[a-z0-9-]+/g); my @FOUND; sub alt { my $arch = shift; for (@_) { `which "$_-as"`; $VARS{$arch}=$_, last unless $?; } if ($VARS{$arch}) { s/\$\($arch\)/$VARS{$arch}/g; } else { $VARS{$arch}="{".join(',', @_)."}"; s/\$\($arch\)/$_[0]/g; } } alt qw(X86 x86_64-linux-gnu i386-linux-gnu i486-linux-gnu i586-linux-gnu i686-linux-gnu x86_64-linux-gnux32); alt qw(MIPS mips-linux-gnu mipsel-linux-gnu mips64-linux-gnuabi64 mips64el-linux-gnuabi64); alt qw(POWERPC powerpc-linux-gnu powerpc64-linux-gnu); alt qw(ARM arm-linux-gnueabihf arm-linux-gnueabi); alt qw(SPARC sparc64-linux-gnu sparc-linux-gnu); while (/^arch-test-([a-z0-9-]+):.*\n\t([a-z0-9_.-]+-(?:gcc|as))/mg) { $ARCH{$1} or die "Error: $1 known but not listed.\n"; delete $ARCH{$1}; `which $2`; if ($?) { print "Missing $1: $2 not installed\n"; } else { print "$1: $2\n"; push @FOUND, "$1"; } } die "Error: ".join(' ',keys %ARCH)." listed but not known.\n" if (%ARCH); open CONFIG, ">config"; print CONFIG "ARCHS=@FOUND\n"; print CONFIG "$_=$VARS{$_}\n" for keys %VARS; arch-test-0.7/generic.c000066400000000000000000000001131301755474700150420ustar00rootroot00000000000000#include int main() { write(1, "ok\n", 3); return 0; } arch-test-0.7/hppa.s000066400000000000000000000004041301755474700144010ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: ldi 1, %r26 ldil L'msg, %r25 ldo R'msg(%r25), %r25 ldi 3, %r24 ble 0x100(%sr2,%r0) ldi 4, %r20 ; syscall: write(r26, r25, r24) ldi 0, %r26 ble 0x100(%sr2,%r0) ldi 1, %r20 ; syscall: _exit(r26) arch-test-0.7/i386.s000066400000000000000000000004421301755474700141440ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: cmovz %eax, %ebx # 686 required as of Debian stretch movl $4, %eax # syscall: write(ebx, ecx, edx) movl $1, %ebx movl $msg, %ecx movl $3, %edx int $0x80 xorl %eax, %eax incl %eax # syscall: _exit(bl) xorb %bl, %bl int $0x80 arch-test-0.7/kfreebsd-i386.s000066400000000000000000000004641301755474700157330ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: cmovz %eax, %ebx # 686 required as of Debian stretch pushl $3 pushl $msg pushl $1 mov $4, %eax # syscall: write push %eax int $0x80 add $16, %esp # pop 3 arguments + dummy * 4 bytes pushl $0 mov $1, %eax # syscall: _exit push %eax int $0x80 arch-test-0.7/m68k.s000066400000000000000000000003601301755474700142370ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: moveq.l #1, %d1 lea msg, %a1 move.l %a1, %d2 moveq.l #3, %d3 moveq.l #4, %d0 | syscall: write(d1, d2, d3) trap #0 moveq.l #0, %d1 moveq.l #1, %d0 | syscall: _exit(d1) trap #0 arch-test-0.7/mips.s000066400000000000000000000003371301755474700144260ustar00rootroot00000000000000.rdata msg: .ascii "ok\n" .text .globl __start __start: li $4, 1 la $5, msg li $6, 3 li $2, 4004 syscall move $4, $0 li $2, 4001 syscall # <-- unreachable # exit gracefully on n32 li $4, 1 li $2, 6058 syscall arch-test-0.7/mips64.s000066400000000000000000000002221301755474700145710ustar00rootroot00000000000000.rdata msg: .ascii "ok\n" .text .globl __start __start: li $4, 1 dla $5, msg li $6, 3 li $2, 5001 syscall move $4, $0 li $2, 5058 syscall arch-test-0.7/mipsn32.s000066400000000000000000000003571301755474700147530ustar00rootroot00000000000000.rdata msg: .ascii "ok\n" .text .globl __start __start: li $4, 1 la $5, msg li $6, 3 li $2, 6001 # write syscall move $4, $0 li $2, 6058 # _exit syscall # <-- unreachable # exit gracefully on o32 li $4, 1 li $2, 4001 syscall arch-test-0.7/powerpc.s000066400000000000000000000003361301755474700151340ustar00rootroot00000000000000.rodata msg: .ascii "ok\n" .text .globl _start _start: fsel 0, 1, 2, 3 # boom on SPE li 0, 4 # syscall write(r3, r4, r5) li 3, 1 lis 4, msg@ha addi 4, 4, msg@l li 5, 3 sc li 0, 1 # syscall _exit(r3) li 3, 0 sc arch-test-0.7/powerpcspe.s000066400000000000000000000005351301755474700156450ustar00rootroot00000000000000.rodata msg: .ascii "ok\n" .text .globl _start _start: li 0, 1 # if not SPE but no SIGILL, we want r0=1 (_exit) li 3, 1 # ... with exit code 1 li 4, 4 efscfsi 0, 4 # f0 = r4 (4) efsctsi 0, 0 # r0 = f0 # r0 will be 4 # syscall write(r3, r4, r5) li 3, 1 lis 4, msg@ha addi 4, 4, msg@l li 5, 3 sc li 0, 1 # syscall _exit(r3) li 3, 0 sc arch-test-0.7/ppc64.s000066400000000000000000000005541301755474700144130ustar00rootroot00000000000000.rodata msg: .ascii "ok\n" .text .globl _start .section ".opd","aw" .align 3 _start: .quad ._start,.TOC.@tocbase,0 .previous .global ._start ._start: li 0, 4 # syscall write(r3, r4, r5) li 3, 1 lis 4, msg@highest addi 4, 4, msg@higher rldicr 4, 4, 32, 31 addis 4, 4, msg@h addi 4, 4, msg@l li 5, 3 sc li 0, 1 # syscall _exit(r3) li 3, 0 sc arch-test-0.7/ppc64el.s000066400000000000000000000006321301755474700147310ustar00rootroot00000000000000.rodata msg: .ascii "ok\n" .text .globl _start .section ".opd","aw" .align 3 _start: .quad ._start,.TOC.@tocbase,0 .previous .global ._start ._start: mtvsrd 0, 0 # trigger SIGILL on power7 CPUs li 0, 4 # syscall write(r3, r4, r5) li 3, 1 lis 4, msg@highest addi 4, 4, msg@higher rldicr 4, 4, 32, 31 addis 4, 4, msg@h addi 4, 4, msg@l li 5, 3 sc li 0, 1 # syscall _exit(r3) li 3, 0 sc arch-test-0.7/run-all000077500000000000000000000006211301755474700145660ustar00rootroot00000000000000#!/bin/bash # Verbose script for debug purposes. ulimit -c 0 for x in arch-test-* do arch=${x##arch-test-} printf '\e[33m%s\e[0m\n' "$arch" MSG=`"./$x" 2>/dev/null|tr -d '\r'` RET=$? if [ $RET -eq 0 -a "x$MSG" = "xok" ] then COL="32" # green else COL="31" # red fi printf '\e[%smret=\e[1m%d\e[0;%sm stdout=\e[1m%s\e[0m\n' "$COL" "$RET" "$COL" "$MSG" done arch-test-0.7/s390x.s000066400000000000000000000002541301755474700143420ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: basr %r1, 0 base: la %r2, base sr %r1, %r2 lhi %r2, 1 la %r3, msg(%r1) lhi %r4, 3 svc 4 xr %r2, %r2 svc 1 arch-test-0.7/sh4.s000066400000000000000000000004221301755474700141470ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov #4, r3 ! syscall: write(r4, r5, r6) mov #1, r4 mov.l msg_ptr, r5 mov #3, r6 trapa #0x11 ! 1-argument syscall mov #1, r3 ! syscall: _exit(r4) mov #0, r4 trapa #0x13 ! 3-argument syscall msg_ptr: .long msg arch-test-0.7/solaris-amd64.s000066400000000000000000000006751301755474700160500ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov $3, %rdx mov $msg, %rsi mov $1, %rdi mov $4, %eax # syscall: write(rdi, rsi, rdx) syscall # hack: syscall 1 is write() on Linux, write nothing mov $0, %rdx mov $01, %eax # syscall: _exit(rdi) xor %rdi, %rdi syscall # <-- unreachable on Solaris # hack: don't segfault on Linux, exit cleanly with code 1 mov $60, %rax # Linux syscall: _exit(rdi) mov $1, %rdi syscall arch-test-0.7/sparc.s000066400000000000000000000003421301755474700145620ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov 1, %o0 sethi %hi(msg), %g1 or %g1, %lo(msg), %o1 mov 3, %o2 mov 4, %g1 ! syscall: write(o0, o1, o2) t 0x10 mov 0, %o0 mov 1, %g1 ! syscall: _exit(o0) t 0x10 arch-test-0.7/sparc64.s000066400000000000000000000003421301755474700147340ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov 1, %o0 sethi %hi(msg), %g1 or %g1, %lo(msg), %o1 mov 3, %o2 mov 4, %g1 ! syscall: write(o0, o1, o2) t 0x6d mov 0, %o0 mov 1, %g1 ! syscall: _exit(o0) t 0x6d arch-test-0.7/x32.s000066400000000000000000000003501301755474700140650ustar00rootroot00000000000000.globl _start .data msg: .ascii "ok\n" .text _start: mov $0x40000001, %rax # syscall: write(rdi, rsi, rdx) mov $1, %rdi mov $msg, %rsi mov $3, %rdx syscall mov $0x4000003c, %rax # syscall: _exit(rdi) xor %rdi, %rdi syscall