diff --git a/ape/ape.S b/ape/ape.S index 41d4c2b7e..8c6140760 100644 --- a/ape/ape.S +++ b/ape/ape.S @@ -581,6 +581,9 @@ ape_disk: #if SupportsWindows() || SupportsMetal() || SupportsXnu() apesh: .ascii "\n@\n#'\"\n" # sixth edition shebang + .ascii "m=\"$(uname -m)\"\n" + + .ascii "if [ \"$m\" = x86_64 ]; then\n" // Until all operating systems can be updated to support APE, // we have a beautiful, yet imperfect workaround, which is to // modify the binary to follow the local system's convention. @@ -682,17 +685,294 @@ apesh: .ascii "\n@\n#'\"\n" # sixth edition shebang .ascii "o=\"$t\"\n" .ascii "exec \"$o\" \"$@\"\n" #endif /* APE_NO_MODIFY_SELF */ - .ascii "R=$?\n" - .ascii "if [ \"$(uname -m)\" != x86_64 ]; then\n" - .ascii "Q=\"$(command -v qemu-x86_64)\" &&\n" - .ascii "exec \"$Q\" \"$o\" \"$@\"\n" -#ifndef APE_NO_MODIFY_SELF - .ascii "else\n" # means argv[0] was wrong - .ascii " exec \"$o\" \"$@\"\n" # so do a path resolution -#endif /* APE_NO_MODIFY_SELF */ + .ascii "exit $?\n" .ascii "fi\n" - .ascii "exit $R\n" + + .ascii "PHDRS='' <<'@'\n" .endobj apesh +// elf program headers get inserted here +// because they need to be in the first 4096 bytes + .section .emush,"a",@progbits +emush: .ascii "\n@\n#'\"\n" + +// our script is running on a non-x86_64 architecture +// 1. `dd` out the appropriate blink vm blob +// 2. gunzip the blink virtual machine executable +// 3. relaunch this program inside the blink vm + .ascii "o=\"$(command -v \"$0\")\"\n" + .ascii "e=\"${TMPDIR:-${HOME:-.}}/.ape-blink-1.0\"\n" + +// Blink for Aarch64 Linux, e.g. Raspberry Pi + .ascii "if [ \"$m\" = aarch64 ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-aarch64 to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_aarch64_b9 + .byte blink_aarch64_b8 + .byte blink_aarch64_b7 + .byte blink_aarch64_b6 + .byte blink_aarch64_b5 + .byte blink_aarch64_b4 + .byte blink_aarch64_b3 + .byte blink_aarch64_b2 + .byte blink_aarch64_b1 + .byte blink_aarch64_b0 + .ascii ")) count=$((" + .byte blink_aarch64_size_b9 + .byte blink_aarch64_size_b8 + .byte blink_aarch64_size_b7 + .byte blink_aarch64_size_b6 + .byte blink_aarch64_size_b5 + .byte blink_aarch64_size_b4 + .byte blink_aarch64_size_b3 + .byte blink_aarch64_size_b2 + .byte blink_aarch64_size_b1 + .byte blink_aarch64_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + +// Blink for Apple Silicon, e.g. M1 Macbook + .ascii "if [ \"$m\" = arm64 ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-darwin-arm64 to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_darwin_arm64_b9 + .byte blink_darwin_arm64_b8 + .byte blink_darwin_arm64_b7 + .byte blink_darwin_arm64_b6 + .byte blink_darwin_arm64_b5 + .byte blink_darwin_arm64_b4 + .byte blink_darwin_arm64_b3 + .byte blink_darwin_arm64_b2 + .byte blink_darwin_arm64_b1 + .byte blink_darwin_arm64_b0 + .ascii ")) count=$((" + .byte blink_darwin_arm64_size_b9 + .byte blink_darwin_arm64_size_b8 + .byte blink_darwin_arm64_size_b7 + .byte blink_darwin_arm64_size_b6 + .byte blink_darwin_arm64_size_b5 + .byte blink_darwin_arm64_size_b4 + .byte blink_darwin_arm64_size_b3 + .byte blink_darwin_arm64_size_b2 + .byte blink_darwin_arm64_size_b1 + .byte blink_darwin_arm64_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + +// Blink for Linux Generic ARM + .ascii "if [ \"${m#arm}\" != \"$m\" ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-arm to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_arm_b9 + .byte blink_arm_b8 + .byte blink_arm_b7 + .byte blink_arm_b6 + .byte blink_arm_b5 + .byte blink_arm_b4 + .byte blink_arm_b3 + .byte blink_arm_b2 + .byte blink_arm_b1 + .byte blink_arm_b0 + .ascii ")) count=$((" + .byte blink_arm_size_b9 + .byte blink_arm_size_b8 + .byte blink_arm_size_b7 + .byte blink_arm_size_b6 + .byte blink_arm_size_b5 + .byte blink_arm_size_b4 + .byte blink_arm_size_b3 + .byte blink_arm_size_b2 + .byte blink_arm_size_b1 + .byte blink_arm_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + +// Blink for Linux on Legacy x86 + .ascii "if [ \"$m\" = i686 ] || [ \"$m\" = i386 ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-i486 to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_i486_b9 + .byte blink_i486_b8 + .byte blink_i486_b7 + .byte blink_i486_b6 + .byte blink_i486_b5 + .byte blink_i486_b4 + .byte blink_i486_b3 + .byte blink_i486_b2 + .byte blink_i486_b1 + .byte blink_i486_b0 + .ascii ")) count=$((" + .byte blink_i486_size_b9 + .byte blink_i486_size_b8 + .byte blink_i486_size_b7 + .byte blink_i486_size_b6 + .byte blink_i486_size_b5 + .byte blink_i486_size_b4 + .byte blink_i486_size_b3 + .byte blink_i486_size_b2 + .byte blink_i486_size_b1 + .byte blink_i486_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + +// Blink for Linux on RISC-V + .ascii "if [ \"$m\" = riscv64 ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-riscv64 to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_riscv64_b9 + .byte blink_riscv64_b8 + .byte blink_riscv64_b7 + .byte blink_riscv64_b6 + .byte blink_riscv64_b5 + .byte blink_riscv64_b4 + .byte blink_riscv64_b3 + .byte blink_riscv64_b2 + .byte blink_riscv64_b1 + .byte blink_riscv64_b0 + .ascii ")) count=$((" + .byte blink_riscv64_size_b9 + .byte blink_riscv64_size_b8 + .byte blink_riscv64_size_b7 + .byte blink_riscv64_size_b6 + .byte blink_riscv64_size_b5 + .byte blink_riscv64_size_b4 + .byte blink_riscv64_size_b3 + .byte blink_riscv64_size_b2 + .byte blink_riscv64_size_b1 + .byte blink_riscv64_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + +// Blink for Linux on MIPS Little Endian, e.g. Ubiquiti EdgerouterX + .ascii "if [ \"$m\" = mips ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-mipsel to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_mipsel_b9 + .byte blink_mipsel_b8 + .byte blink_mipsel_b7 + .byte blink_mipsel_b6 + .byte blink_mipsel_b5 + .byte blink_mipsel_b4 + .byte blink_mipsel_b3 + .byte blink_mipsel_b2 + .byte blink_mipsel_b1 + .byte blink_mipsel_b0 + .ascii ")) count=$((" + .byte blink_mipsel_size_b9 + .byte blink_mipsel_size_b8 + .byte blink_mipsel_size_b7 + .byte blink_mipsel_size_b6 + .byte blink_mipsel_size_b5 + .byte blink_mipsel_size_b4 + .byte blink_mipsel_size_b3 + .byte blink_mipsel_size_b2 + .byte blink_mipsel_size_b1 + .byte blink_mipsel_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + +// Blink for Linux on PowerPC, e.g. Old Macintosh + .ascii "if [ \"$m\" = ppc ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-powerpc to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_powerpc_b9 + .byte blink_powerpc_b8 + .byte blink_powerpc_b7 + .byte blink_powerpc_b6 + .byte blink_powerpc_b5 + .byte blink_powerpc_b4 + .byte blink_powerpc_b3 + .byte blink_powerpc_b2 + .byte blink_powerpc_b1 + .byte blink_powerpc_b0 + .ascii ")) count=$((" + .byte blink_powerpc_size_b9 + .byte blink_powerpc_size_b8 + .byte blink_powerpc_size_b7 + .byte blink_powerpc_size_b6 + .byte blink_powerpc_size_b5 + .byte blink_powerpc_size_b4 + .byte blink_powerpc_size_b3 + .byte blink_powerpc_size_b2 + .byte blink_powerpc_size_b1 + .byte blink_powerpc_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + +// Blink for Linux on IBM Mainframes + .ascii "if [ \"$m\" = s390x ]; then\n" + .ascii "if ! [ -x \"$e\" ]; then\n" + .ascii "echo \"extracting blink-s390x to ${e}\" >&2\n" + .ascii "dd if=\"$o\" bs=1 skip=$((" + .byte blink_s390x_b9 + .byte blink_s390x_b8 + .byte blink_s390x_b7 + .byte blink_s390x_b6 + .byte blink_s390x_b5 + .byte blink_s390x_b4 + .byte blink_s390x_b3 + .byte blink_s390x_b2 + .byte blink_s390x_b1 + .byte blink_s390x_b0 + .ascii ")) count=$((" + .byte blink_s390x_size_b9 + .byte blink_s390x_size_b8 + .byte blink_s390x_size_b7 + .byte blink_s390x_size_b6 + .byte blink_s390x_size_b5 + .byte blink_s390x_size_b4 + .byte blink_s390x_size_b3 + .byte blink_s390x_size_b2 + .byte blink_s390x_size_b1 + .byte blink_s390x_size_b0 + .ascii ")) conv=notrunc 2>/dev/null | gunzip >\"$e.$$\"\n" + .ascii "mv -f \"$e.$$\" \"$e\"\n" + .ascii "chmod +x \"$e\"\n" + .ascii "fi\n" + .ascii "exec \"$e\" \"$o\" \"$@\"\n" + .ascii "fi\n" + + .ascii "echo unsupported architecture >&2\n" + .rept 16 + .ascii "exit 127\n" + .endr + + .ascii "exit 1\n" + .endobj emush #ifdef APE_LOADER .section .ape.loader,"a",@progbits .align 64 @@ -1838,5 +2118,69 @@ __bss_start: __bss_end: .previous + .section .blink,"a",@progbits + .globl blink_aarch64_size +blink_aarch64: + .incbin "ape/blink-aarch64.gz" + .endobj blink_aarch64,globl +blink_aarch64_size = . - blink_aarch64 + .previous + + .section .blink,"a",@progbits + .globl blink_darwin_arm64_size +blink_darwin_arm64: + .incbin "ape/blink-darwin-arm64.gz" + .endobj blink_darwin_arm64,globl +blink_darwin_arm64_size = . - blink_darwin_arm64 + .previous + + .section .blink,"a",@progbits + .globl blink_arm_size +blink_arm: + .incbin "ape/blink-arm.gz" + .endobj blink_arm,globl +blink_arm_size = . - blink_arm + .previous + + .section .blink,"a",@progbits + .globl blink_i486_size +blink_i486: + .incbin "ape/blink-i486.gz" + .endobj blink_i486,globl +blink_i486_size = . - blink_i486 + .previous + + .section .blink,"a",@progbits + .globl blink_riscv64_size +blink_riscv64: + .incbin "ape/blink-riscv64.gz" + .endobj blink_riscv64,globl +blink_riscv64_size = . - blink_riscv64 + .previous + + .section .blink,"a",@progbits + .globl blink_mipsel_size +blink_mipsel: + .incbin "ape/blink-mipsel.gz" + .endobj blink_mipsel,globl +blink_mipsel_size = . - blink_mipsel + .previous + + .section .blink,"a",@progbits + .globl blink_powerpc_size +blink_powerpc: + .incbin "ape/blink-powerpc.gz" + .endobj blink_powerpc,globl +blink_powerpc_size = . - blink_powerpc + .previous + + .section .blink,"a",@progbits + .globl blink_s390x_size +blink_s390x: + .incbin "ape/blink-s390x.gz" + .endobj blink_s390x,globl +blink_s390x_size = . - blink_s390x + .previous + .end  \ No newline at end of file diff --git a/ape/ape.lds b/ape/ape.lds index c40739b6d..c60a1c5e4 100644 --- a/ape/ape.lds +++ b/ape/ape.lds @@ -216,6 +216,8 @@ SECTIONS { KEEP(*(.elf.phdrs)) HIDDEN(ape_phdrs_end = .); + KEEP(*(.emush)) + /* OpenBSD */ . = ALIGN(__SIZEOF_POINTER__); HIDDEN(ape_note = .); @@ -273,6 +275,7 @@ SECTIONS { KEEP(*(.textwindowsprologue)) *(.text.windows) KEEP(*(.textwindowsepilogue)) + KEEP(*(.blink)) *(SORT_BY_ALIGNMENT(.text.modernity)) *(SORT_BY_ALIGNMENT(.text.modernity.*)) *(SORT_BY_ALIGNMENT(.text.hot)) @@ -564,6 +567,182 @@ SHSTUB2(ape_loader_dd_count, ? ROUNDUP(ape_loader_end - ape_loader, PAGESIZE) / 64 : 0); +HIDDEN(blink_aarch64_b0 = RVA(blink_aarch64) % 10 + 48); +HIDDEN(blink_aarch64_b1 = RVA(blink_aarch64) < 10 ? 32 : RVA(blink_aarch64) / 10 % 10 + 48); +HIDDEN(blink_aarch64_b2 = RVA(blink_aarch64) < 100 ? 32 : RVA(blink_aarch64) / 100 % 10 + 48); +HIDDEN(blink_aarch64_b3 = RVA(blink_aarch64) < 1000 ? 32 : RVA(blink_aarch64) / 1000 % 10 + 48); +HIDDEN(blink_aarch64_b4 = RVA(blink_aarch64) < 10000 ? 32 : RVA(blink_aarch64) / 10000 % 10 + 48); +HIDDEN(blink_aarch64_b5 = RVA(blink_aarch64) < 100000 ? 32 : RVA(blink_aarch64) / 100000 % 10 + 48); +HIDDEN(blink_aarch64_b6 = RVA(blink_aarch64) < 1000000 ? 32 : RVA(blink_aarch64) / 1000000 % 10 + 48); +HIDDEN(blink_aarch64_b7 = RVA(blink_aarch64) < 10000000 ? 32 : RVA(blink_aarch64) / 10000000 % 10 + 48); +HIDDEN(blink_aarch64_b8 = RVA(blink_aarch64) < 100000000 ? 32 : RVA(blink_aarch64) / 100000000 % 10 + 48); +HIDDEN(blink_aarch64_b9 = RVA(blink_aarch64) < 1000000000 ? 32 : RVA(blink_aarch64) / 1000000000 % 10 + 48); + +HIDDEN(blink_aarch64_size_b0 = blink_aarch64_size % 10 + 48); +HIDDEN(blink_aarch64_size_b1 = blink_aarch64_size < 10 ? 32 : blink_aarch64_size / 10 % 10 + 48); +HIDDEN(blink_aarch64_size_b2 = blink_aarch64_size < 100 ? 32 : blink_aarch64_size / 100 % 10 + 48); +HIDDEN(blink_aarch64_size_b3 = blink_aarch64_size < 1000 ? 32 : blink_aarch64_size / 1000 % 10 + 48); +HIDDEN(blink_aarch64_size_b4 = blink_aarch64_size < 10000 ? 32 : blink_aarch64_size / 10000 % 10 + 48); +HIDDEN(blink_aarch64_size_b5 = blink_aarch64_size < 100000 ? 32 : blink_aarch64_size / 100000 % 10 + 48); +HIDDEN(blink_aarch64_size_b6 = blink_aarch64_size < 1000000 ? 32 : blink_aarch64_size / 1000000 % 10 + 48); +HIDDEN(blink_aarch64_size_b7 = blink_aarch64_size < 10000000 ? 32 : blink_aarch64_size / 10000000 % 10 + 48); +HIDDEN(blink_aarch64_size_b8 = blink_aarch64_size < 100000000 ? 32 : blink_aarch64_size / 100000000 % 10 + 48); +HIDDEN(blink_aarch64_size_b9 = blink_aarch64_size < 1000000000 ? 32 : blink_aarch64_size / 1000000000 % 10 + 48); + +HIDDEN(blink_darwin_arm64_b0 = RVA(blink_darwin_arm64) % 10 + 48); +HIDDEN(blink_darwin_arm64_b1 = RVA(blink_darwin_arm64) < 10 ? 32 : RVA(blink_darwin_arm64) / 10 % 10 + 48); +HIDDEN(blink_darwin_arm64_b2 = RVA(blink_darwin_arm64) < 100 ? 32 : RVA(blink_darwin_arm64) / 100 % 10 + 48); +HIDDEN(blink_darwin_arm64_b3 = RVA(blink_darwin_arm64) < 1000 ? 32 : RVA(blink_darwin_arm64) / 1000 % 10 + 48); +HIDDEN(blink_darwin_arm64_b4 = RVA(blink_darwin_arm64) < 10000 ? 32 : RVA(blink_darwin_arm64) / 10000 % 10 + 48); +HIDDEN(blink_darwin_arm64_b5 = RVA(blink_darwin_arm64) < 100000 ? 32 : RVA(blink_darwin_arm64) / 100000 % 10 + 48); +HIDDEN(blink_darwin_arm64_b6 = RVA(blink_darwin_arm64) < 1000000 ? 32 : RVA(blink_darwin_arm64) / 1000000 % 10 + 48); +HIDDEN(blink_darwin_arm64_b7 = RVA(blink_darwin_arm64) < 10000000 ? 32 : RVA(blink_darwin_arm64) / 10000000 % 10 + 48); +HIDDEN(blink_darwin_arm64_b8 = RVA(blink_darwin_arm64) < 100000000 ? 32 : RVA(blink_darwin_arm64) / 100000000 % 10 + 48); +HIDDEN(blink_darwin_arm64_b9 = RVA(blink_darwin_arm64) < 1000000000 ? 32 : RVA(blink_darwin_arm64) / 1000000000 % 10 + 48); + +HIDDEN(blink_darwin_arm64_size_b0 = blink_darwin_arm64_size % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b1 = blink_darwin_arm64_size < 10 ? 32 : blink_darwin_arm64_size / 10 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b2 = blink_darwin_arm64_size < 100 ? 32 : blink_darwin_arm64_size / 100 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b3 = blink_darwin_arm64_size < 1000 ? 32 : blink_darwin_arm64_size / 1000 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b4 = blink_darwin_arm64_size < 10000 ? 32 : blink_darwin_arm64_size / 10000 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b5 = blink_darwin_arm64_size < 100000 ? 32 : blink_darwin_arm64_size / 100000 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b6 = blink_darwin_arm64_size < 1000000 ? 32 : blink_darwin_arm64_size / 1000000 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b7 = blink_darwin_arm64_size < 10000000 ? 32 : blink_darwin_arm64_size / 10000000 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b8 = blink_darwin_arm64_size < 100000000 ? 32 : blink_darwin_arm64_size / 100000000 % 10 + 48); +HIDDEN(blink_darwin_arm64_size_b9 = blink_darwin_arm64_size < 1000000000 ? 32 : blink_darwin_arm64_size / 1000000000 % 10 + 48); + +HIDDEN(blink_arm_b0 = RVA(blink_arm) % 10 + 48); +HIDDEN(blink_arm_b1 = RVA(blink_arm) < 10 ? 32 : RVA(blink_arm) / 10 % 10 + 48); +HIDDEN(blink_arm_b2 = RVA(blink_arm) < 100 ? 32 : RVA(blink_arm) / 100 % 10 + 48); +HIDDEN(blink_arm_b3 = RVA(blink_arm) < 1000 ? 32 : RVA(blink_arm) / 1000 % 10 + 48); +HIDDEN(blink_arm_b4 = RVA(blink_arm) < 10000 ? 32 : RVA(blink_arm) / 10000 % 10 + 48); +HIDDEN(blink_arm_b5 = RVA(blink_arm) < 100000 ? 32 : RVA(blink_arm) / 100000 % 10 + 48); +HIDDEN(blink_arm_b6 = RVA(blink_arm) < 1000000 ? 32 : RVA(blink_arm) / 1000000 % 10 + 48); +HIDDEN(blink_arm_b7 = RVA(blink_arm) < 10000000 ? 32 : RVA(blink_arm) / 10000000 % 10 + 48); +HIDDEN(blink_arm_b8 = RVA(blink_arm) < 100000000 ? 32 : RVA(blink_arm) / 100000000 % 10 + 48); +HIDDEN(blink_arm_b9 = RVA(blink_arm) < 1000000000 ? 32 : RVA(blink_arm) / 1000000000 % 10 + 48); + +HIDDEN(blink_arm_size_b0 = blink_arm_size % 10 + 48); +HIDDEN(blink_arm_size_b1 = blink_arm_size < 10 ? 32 : blink_arm_size / 10 % 10 + 48); +HIDDEN(blink_arm_size_b2 = blink_arm_size < 100 ? 32 : blink_arm_size / 100 % 10 + 48); +HIDDEN(blink_arm_size_b3 = blink_arm_size < 1000 ? 32 : blink_arm_size / 1000 % 10 + 48); +HIDDEN(blink_arm_size_b4 = blink_arm_size < 10000 ? 32 : blink_arm_size / 10000 % 10 + 48); +HIDDEN(blink_arm_size_b5 = blink_arm_size < 100000 ? 32 : blink_arm_size / 100000 % 10 + 48); +HIDDEN(blink_arm_size_b6 = blink_arm_size < 1000000 ? 32 : blink_arm_size / 1000000 % 10 + 48); +HIDDEN(blink_arm_size_b7 = blink_arm_size < 10000000 ? 32 : blink_arm_size / 10000000 % 10 + 48); +HIDDEN(blink_arm_size_b8 = blink_arm_size < 100000000 ? 32 : blink_arm_size / 100000000 % 10 + 48); +HIDDEN(blink_arm_size_b9 = blink_arm_size < 1000000000 ? 32 : blink_arm_size / 1000000000 % 10 + 48); + +HIDDEN(blink_i486_b0 = RVA(blink_i486) % 10 + 48); +HIDDEN(blink_i486_b1 = RVA(blink_i486) < 10 ? 32 : RVA(blink_i486) / 10 % 10 + 48); +HIDDEN(blink_i486_b2 = RVA(blink_i486) < 100 ? 32 : RVA(blink_i486) / 100 % 10 + 48); +HIDDEN(blink_i486_b3 = RVA(blink_i486) < 1000 ? 32 : RVA(blink_i486) / 1000 % 10 + 48); +HIDDEN(blink_i486_b4 = RVA(blink_i486) < 10000 ? 32 : RVA(blink_i486) / 10000 % 10 + 48); +HIDDEN(blink_i486_b5 = RVA(blink_i486) < 100000 ? 32 : RVA(blink_i486) / 100000 % 10 + 48); +HIDDEN(blink_i486_b6 = RVA(blink_i486) < 1000000 ? 32 : RVA(blink_i486) / 1000000 % 10 + 48); +HIDDEN(blink_i486_b7 = RVA(blink_i486) < 10000000 ? 32 : RVA(blink_i486) / 10000000 % 10 + 48); +HIDDEN(blink_i486_b8 = RVA(blink_i486) < 100000000 ? 32 : RVA(blink_i486) / 100000000 % 10 + 48); +HIDDEN(blink_i486_b9 = RVA(blink_i486) < 1000000000 ? 32 : RVA(blink_i486) / 1000000000 % 10 + 48); + +HIDDEN(blink_i486_size_b0 = blink_i486_size % 10 + 48); +HIDDEN(blink_i486_size_b1 = blink_i486_size < 10 ? 32 : blink_i486_size / 10 % 10 + 48); +HIDDEN(blink_i486_size_b2 = blink_i486_size < 100 ? 32 : blink_i486_size / 100 % 10 + 48); +HIDDEN(blink_i486_size_b3 = blink_i486_size < 1000 ? 32 : blink_i486_size / 1000 % 10 + 48); +HIDDEN(blink_i486_size_b4 = blink_i486_size < 10000 ? 32 : blink_i486_size / 10000 % 10 + 48); +HIDDEN(blink_i486_size_b5 = blink_i486_size < 100000 ? 32 : blink_i486_size / 100000 % 10 + 48); +HIDDEN(blink_i486_size_b6 = blink_i486_size < 1000000 ? 32 : blink_i486_size / 1000000 % 10 + 48); +HIDDEN(blink_i486_size_b7 = blink_i486_size < 10000000 ? 32 : blink_i486_size / 10000000 % 10 + 48); +HIDDEN(blink_i486_size_b8 = blink_i486_size < 100000000 ? 32 : blink_i486_size / 100000000 % 10 + 48); +HIDDEN(blink_i486_size_b9 = blink_i486_size < 1000000000 ? 32 : blink_i486_size / 1000000000 % 10 + 48); + +HIDDEN(blink_riscv64_b0 = RVA(blink_riscv64) % 10 + 48); +HIDDEN(blink_riscv64_b1 = RVA(blink_riscv64) < 10 ? 32 : RVA(blink_riscv64) / 10 % 10 + 48); +HIDDEN(blink_riscv64_b2 = RVA(blink_riscv64) < 100 ? 32 : RVA(blink_riscv64) / 100 % 10 + 48); +HIDDEN(blink_riscv64_b3 = RVA(blink_riscv64) < 1000 ? 32 : RVA(blink_riscv64) / 1000 % 10 + 48); +HIDDEN(blink_riscv64_b4 = RVA(blink_riscv64) < 10000 ? 32 : RVA(blink_riscv64) / 10000 % 10 + 48); +HIDDEN(blink_riscv64_b5 = RVA(blink_riscv64) < 100000 ? 32 : RVA(blink_riscv64) / 100000 % 10 + 48); +HIDDEN(blink_riscv64_b6 = RVA(blink_riscv64) < 1000000 ? 32 : RVA(blink_riscv64) / 1000000 % 10 + 48); +HIDDEN(blink_riscv64_b7 = RVA(blink_riscv64) < 10000000 ? 32 : RVA(blink_riscv64) / 10000000 % 10 + 48); +HIDDEN(blink_riscv64_b8 = RVA(blink_riscv64) < 100000000 ? 32 : RVA(blink_riscv64) / 100000000 % 10 + 48); +HIDDEN(blink_riscv64_b9 = RVA(blink_riscv64) < 1000000000 ? 32 : RVA(blink_riscv64) / 1000000000 % 10 + 48); + +HIDDEN(blink_riscv64_size_b0 = blink_riscv64_size % 10 + 48); +HIDDEN(blink_riscv64_size_b1 = blink_riscv64_size < 10 ? 32 : blink_riscv64_size / 10 % 10 + 48); +HIDDEN(blink_riscv64_size_b2 = blink_riscv64_size < 100 ? 32 : blink_riscv64_size / 100 % 10 + 48); +HIDDEN(blink_riscv64_size_b3 = blink_riscv64_size < 1000 ? 32 : blink_riscv64_size / 1000 % 10 + 48); +HIDDEN(blink_riscv64_size_b4 = blink_riscv64_size < 10000 ? 32 : blink_riscv64_size / 10000 % 10 + 48); +HIDDEN(blink_riscv64_size_b5 = blink_riscv64_size < 100000 ? 32 : blink_riscv64_size / 100000 % 10 + 48); +HIDDEN(blink_riscv64_size_b6 = blink_riscv64_size < 1000000 ? 32 : blink_riscv64_size / 1000000 % 10 + 48); +HIDDEN(blink_riscv64_size_b7 = blink_riscv64_size < 10000000 ? 32 : blink_riscv64_size / 10000000 % 10 + 48); +HIDDEN(blink_riscv64_size_b8 = blink_riscv64_size < 100000000 ? 32 : blink_riscv64_size / 100000000 % 10 + 48); +HIDDEN(blink_riscv64_size_b9 = blink_riscv64_size < 1000000000 ? 32 : blink_riscv64_size / 1000000000 % 10 + 48); + +HIDDEN(blink_mipsel_b0 = RVA(blink_mipsel) % 10 + 48); +HIDDEN(blink_mipsel_b1 = RVA(blink_mipsel) < 10 ? 32 : RVA(blink_mipsel) / 10 % 10 + 48); +HIDDEN(blink_mipsel_b2 = RVA(blink_mipsel) < 100 ? 32 : RVA(blink_mipsel) / 100 % 10 + 48); +HIDDEN(blink_mipsel_b3 = RVA(blink_mipsel) < 1000 ? 32 : RVA(blink_mipsel) / 1000 % 10 + 48); +HIDDEN(blink_mipsel_b4 = RVA(blink_mipsel) < 10000 ? 32 : RVA(blink_mipsel) / 10000 % 10 + 48); +HIDDEN(blink_mipsel_b5 = RVA(blink_mipsel) < 100000 ? 32 : RVA(blink_mipsel) / 100000 % 10 + 48); +HIDDEN(blink_mipsel_b6 = RVA(blink_mipsel) < 1000000 ? 32 : RVA(blink_mipsel) / 1000000 % 10 + 48); +HIDDEN(blink_mipsel_b7 = RVA(blink_mipsel) < 10000000 ? 32 : RVA(blink_mipsel) / 10000000 % 10 + 48); +HIDDEN(blink_mipsel_b8 = RVA(blink_mipsel) < 100000000 ? 32 : RVA(blink_mipsel) / 100000000 % 10 + 48); +HIDDEN(blink_mipsel_b9 = RVA(blink_mipsel) < 1000000000 ? 32 : RVA(blink_mipsel) / 1000000000 % 10 + 48); + +HIDDEN(blink_mipsel_size_b0 = blink_mipsel_size % 10 + 48); +HIDDEN(blink_mipsel_size_b1 = blink_mipsel_size < 10 ? 32 : blink_mipsel_size / 10 % 10 + 48); +HIDDEN(blink_mipsel_size_b2 = blink_mipsel_size < 100 ? 32 : blink_mipsel_size / 100 % 10 + 48); +HIDDEN(blink_mipsel_size_b3 = blink_mipsel_size < 1000 ? 32 : blink_mipsel_size / 1000 % 10 + 48); +HIDDEN(blink_mipsel_size_b4 = blink_mipsel_size < 10000 ? 32 : blink_mipsel_size / 10000 % 10 + 48); +HIDDEN(blink_mipsel_size_b5 = blink_mipsel_size < 100000 ? 32 : blink_mipsel_size / 100000 % 10 + 48); +HIDDEN(blink_mipsel_size_b6 = blink_mipsel_size < 1000000 ? 32 : blink_mipsel_size / 1000000 % 10 + 48); +HIDDEN(blink_mipsel_size_b7 = blink_mipsel_size < 10000000 ? 32 : blink_mipsel_size / 10000000 % 10 + 48); +HIDDEN(blink_mipsel_size_b8 = blink_mipsel_size < 100000000 ? 32 : blink_mipsel_size / 100000000 % 10 + 48); +HIDDEN(blink_mipsel_size_b9 = blink_mipsel_size < 1000000000 ? 32 : blink_mipsel_size / 1000000000 % 10 + 48); + +HIDDEN(blink_powerpc_b0 = RVA(blink_powerpc) % 10 + 48); +HIDDEN(blink_powerpc_b1 = RVA(blink_powerpc) < 10 ? 32 : RVA(blink_powerpc) / 10 % 10 + 48); +HIDDEN(blink_powerpc_b2 = RVA(blink_powerpc) < 100 ? 32 : RVA(blink_powerpc) / 100 % 10 + 48); +HIDDEN(blink_powerpc_b3 = RVA(blink_powerpc) < 1000 ? 32 : RVA(blink_powerpc) / 1000 % 10 + 48); +HIDDEN(blink_powerpc_b4 = RVA(blink_powerpc) < 10000 ? 32 : RVA(blink_powerpc) / 10000 % 10 + 48); +HIDDEN(blink_powerpc_b5 = RVA(blink_powerpc) < 100000 ? 32 : RVA(blink_powerpc) / 100000 % 10 + 48); +HIDDEN(blink_powerpc_b6 = RVA(blink_powerpc) < 1000000 ? 32 : RVA(blink_powerpc) / 1000000 % 10 + 48); +HIDDEN(blink_powerpc_b7 = RVA(blink_powerpc) < 10000000 ? 32 : RVA(blink_powerpc) / 10000000 % 10 + 48); +HIDDEN(blink_powerpc_b8 = RVA(blink_powerpc) < 100000000 ? 32 : RVA(blink_powerpc) / 100000000 % 10 + 48); +HIDDEN(blink_powerpc_b9 = RVA(blink_powerpc) < 1000000000 ? 32 : RVA(blink_powerpc) / 1000000000 % 10 + 48); + +HIDDEN(blink_powerpc_size_b0 = blink_powerpc_size % 10 + 48); +HIDDEN(blink_powerpc_size_b1 = blink_powerpc_size < 10 ? 32 : blink_powerpc_size / 10 % 10 + 48); +HIDDEN(blink_powerpc_size_b2 = blink_powerpc_size < 100 ? 32 : blink_powerpc_size / 100 % 10 + 48); +HIDDEN(blink_powerpc_size_b3 = blink_powerpc_size < 1000 ? 32 : blink_powerpc_size / 1000 % 10 + 48); +HIDDEN(blink_powerpc_size_b4 = blink_powerpc_size < 10000 ? 32 : blink_powerpc_size / 10000 % 10 + 48); +HIDDEN(blink_powerpc_size_b5 = blink_powerpc_size < 100000 ? 32 : blink_powerpc_size / 100000 % 10 + 48); +HIDDEN(blink_powerpc_size_b6 = blink_powerpc_size < 1000000 ? 32 : blink_powerpc_size / 1000000 % 10 + 48); +HIDDEN(blink_powerpc_size_b7 = blink_powerpc_size < 10000000 ? 32 : blink_powerpc_size / 10000000 % 10 + 48); +HIDDEN(blink_powerpc_size_b8 = blink_powerpc_size < 100000000 ? 32 : blink_powerpc_size / 100000000 % 10 + 48); +HIDDEN(blink_powerpc_size_b9 = blink_powerpc_size < 1000000000 ? 32 : blink_powerpc_size / 1000000000 % 10 + 48); + +HIDDEN(blink_s390x_b0 = RVA(blink_s390x) % 10 + 48); +HIDDEN(blink_s390x_b1 = RVA(blink_s390x) < 10 ? 32 : RVA(blink_s390x) / 10 % 10 + 48); +HIDDEN(blink_s390x_b2 = RVA(blink_s390x) < 100 ? 32 : RVA(blink_s390x) / 100 % 10 + 48); +HIDDEN(blink_s390x_b3 = RVA(blink_s390x) < 1000 ? 32 : RVA(blink_s390x) / 1000 % 10 + 48); +HIDDEN(blink_s390x_b4 = RVA(blink_s390x) < 10000 ? 32 : RVA(blink_s390x) / 10000 % 10 + 48); +HIDDEN(blink_s390x_b5 = RVA(blink_s390x) < 100000 ? 32 : RVA(blink_s390x) / 100000 % 10 + 48); +HIDDEN(blink_s390x_b6 = RVA(blink_s390x) < 1000000 ? 32 : RVA(blink_s390x) / 1000000 % 10 + 48); +HIDDEN(blink_s390x_b7 = RVA(blink_s390x) < 10000000 ? 32 : RVA(blink_s390x) / 10000000 % 10 + 48); +HIDDEN(blink_s390x_b8 = RVA(blink_s390x) < 100000000 ? 32 : RVA(blink_s390x) / 100000000 % 10 + 48); +HIDDEN(blink_s390x_b9 = RVA(blink_s390x) < 1000000000 ? 32 : RVA(blink_s390x) / 1000000000 % 10 + 48); + +HIDDEN(blink_s390x_size_b0 = blink_s390x_size % 10 + 48); +HIDDEN(blink_s390x_size_b1 = blink_s390x_size < 10 ? 32 : blink_s390x_size / 10 % 10 + 48); +HIDDEN(blink_s390x_size_b2 = blink_s390x_size < 100 ? 32 : blink_s390x_size / 100 % 10 + 48); +HIDDEN(blink_s390x_size_b3 = blink_s390x_size < 1000 ? 32 : blink_s390x_size / 1000 % 10 + 48); +HIDDEN(blink_s390x_size_b4 = blink_s390x_size < 10000 ? 32 : blink_s390x_size / 10000 % 10 + 48); +HIDDEN(blink_s390x_size_b5 = blink_s390x_size < 100000 ? 32 : blink_s390x_size / 100000 % 10 + 48); +HIDDEN(blink_s390x_size_b6 = blink_s390x_size < 1000000 ? 32 : blink_s390x_size / 1000000 % 10 + 48); +HIDDEN(blink_s390x_size_b7 = blink_s390x_size < 10000000 ? 32 : blink_s390x_size / 10000000 % 10 + 48); +HIDDEN(blink_s390x_size_b8 = blink_s390x_size < 100000000 ? 32 : blink_s390x_size / 100000000 % 10 + 48); +HIDDEN(blink_s390x_size_b9 = blink_s390x_size < 1000000000 ? 32 : blink_s390x_size / 1000000000 % 10 + 48); + #if SupportsMetal() HIDDEN(v_ape_realsectors = MIN(0x70000 - IMAGE_BASE_REAL, ROUNDUP(RVA(_ezip), 512)) / 512); diff --git a/ape/ape.mk b/ape/ape.mk index 48541871f..f4c8bca20 100644 --- a/ape/ape.mk +++ b/ape/ape.mk @@ -96,6 +96,17 @@ o/ape/idata.inc: \ ape/idata.internal.h \ ape/relocations.h +o/$(MODE)/ape/ape.o: \ + ape/blink-aarch64.gz \ + ape/blink-arm.gz \ + ape/blink-darwin-arm64.gz \ + ape/blink-i486.gz \ + ape/blink-mipsel.gz \ + ape/blink-powerpc.gz \ + ape/blink-powerpc64le.gz \ + ape/blink-riscv64.gz \ + ape/blink-s390x.gz + o/$(MODE)/ape/ape-no-modify-self.o: \ ape/ape.S \ ape/macros.internal.h \ @@ -115,6 +126,15 @@ o/$(MODE)/ape/ape-no-modify-self.o: \ libc/runtime/pc.internal.h \ libc/runtime/symbolic.h \ libc/sysv/consts/prot.h \ + ape/blink-aarch64.gz \ + ape/blink-arm.gz \ + ape/blink-darwin-arm64.gz \ + ape/blink-i486.gz \ + ape/blink-mipsel.gz \ + ape/blink-powerpc.gz \ + ape/blink-powerpc64le.gz \ + ape/blink-riscv64.gz \ + ape/blink-s390x.gz \ o/$(MODE)/ape/ape.elf @$(COMPILE) \ -AOBJECTIFY.S \ @@ -141,7 +161,16 @@ o/$(MODE)/ape/ape-copy-self.o: \ libc/runtime/mman.internal.h \ libc/runtime/pc.internal.h \ libc/runtime/symbolic.h \ - libc/sysv/consts/prot.h + libc/sysv/consts/prot.h \ + ape/blink-aarch64.gz \ + ape/blink-arm.gz \ + ape/blink-darwin-arm64.gz \ + ape/blink-i486.gz \ + ape/blink-mipsel.gz \ + ape/blink-powerpc.gz \ + ape/blink-powerpc64le.gz \ + ape/blink-riscv64.gz \ + ape/blink-s390x.gz @$(COMPILE) \ -AOBJECTIFY.S \ $(OBJECTIFY.S) \ diff --git a/ape/blink-aarch64.gz b/ape/blink-aarch64.gz new file mode 100644 index 000000000..3bb409d2d Binary files /dev/null and b/ape/blink-aarch64.gz differ diff --git a/ape/blink-arm.gz b/ape/blink-arm.gz new file mode 100644 index 000000000..6a379feed Binary files /dev/null and b/ape/blink-arm.gz differ diff --git a/ape/blink-arm64.gz b/ape/blink-arm64.gz new file mode 100755 index 000000000..e69de29bb diff --git a/ape/blink-darwin-arm64.gz b/ape/blink-darwin-arm64.gz new file mode 100755 index 000000000..143f7b707 Binary files /dev/null and b/ape/blink-darwin-arm64.gz differ diff --git a/ape/blink-i486.gz b/ape/blink-i486.gz new file mode 100644 index 000000000..58a92af69 Binary files /dev/null and b/ape/blink-i486.gz differ diff --git a/ape/blink-mipsel.gz b/ape/blink-mipsel.gz new file mode 100644 index 000000000..13dd9167a Binary files /dev/null and b/ape/blink-mipsel.gz differ diff --git a/ape/blink-powerpc.gz b/ape/blink-powerpc.gz new file mode 100644 index 000000000..bf627fee4 Binary files /dev/null and b/ape/blink-powerpc.gz differ diff --git a/ape/blink-powerpc64le.gz b/ape/blink-powerpc64le.gz new file mode 100755 index 000000000..e69de29bb diff --git a/ape/blink-riscv64.gz b/ape/blink-riscv64.gz new file mode 100644 index 000000000..79b6993ac Binary files /dev/null and b/ape/blink-riscv64.gz differ diff --git a/ape/blink-s390x.gz b/ape/blink-s390x.gz new file mode 100644 index 000000000..0251c5bb0 Binary files /dev/null and b/ape/blink-s390x.gz differ