mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-03-03 07:29:23 +00:00
Remove non-JIT'd blink builds for now
This commit is contained in:
Justine Tunney
parent
9634227181
commit
0eb621f75e
2 changed files with 0 additions and 443 deletions
289
ape/ape.S
289
ape/ape.S
|
|
@ -771,239 +771,6 @@ emush: .ascii "\n@\n#'\"\n"
|
|||
.ascii "fi\n"
|
||||
.ascii "fi\n"
|
||||
|
||||
// Blink for Linux Generic ARM
|
||||
.ascii "if [ \"$s\" = Linux ] && [ \"${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 [ \"$s\" = Linux ]; then\n"
|
||||
.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"
|
||||
.ascii "fi\n"
|
||||
|
||||
// Blink for Linux on RISC-V
|
||||
.ascii "if [ \"$s\" = Linux ] && [ \"$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 [ \"$s\" = Linux ] && [ \"$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 64 Little Endian, e.g. Raptor
|
||||
.ascii "if [ \"$s\" = Linux ] && [ \"$m\" = ppc64le ]; then\n"
|
||||
.ascii "if ! [ -x \"$e\" ]; then\n"
|
||||
.ascii "echo \"extracting blink-powerpc64le to ${e}\" >&2\n"
|
||||
.ascii "dd if=\"$o\" bs=1 skip=$(("
|
||||
.byte blink_powerpc64le_b9
|
||||
.byte blink_powerpc64le_b8
|
||||
.byte blink_powerpc64le_b7
|
||||
.byte blink_powerpc64le_b6
|
||||
.byte blink_powerpc64le_b5
|
||||
.byte blink_powerpc64le_b4
|
||||
.byte blink_powerpc64le_b3
|
||||
.byte blink_powerpc64le_b2
|
||||
.byte blink_powerpc64le_b1
|
||||
.byte blink_powerpc64le_b0
|
||||
.ascii ")) count=$(("
|
||||
.byte blink_powerpc64le_size_b9
|
||||
.byte blink_powerpc64le_size_b8
|
||||
.byte blink_powerpc64le_size_b7
|
||||
.byte blink_powerpc64le_size_b6
|
||||
.byte blink_powerpc64le_size_b5
|
||||
.byte blink_powerpc64le_size_b4
|
||||
.byte blink_powerpc64le_size_b3
|
||||
.byte blink_powerpc64le_size_b2
|
||||
.byte blink_powerpc64le_size_b1
|
||||
.byte blink_powerpc64le_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 [ \"$s\" = Linux ] && [ \"$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 [ \"$s\" = Linux ] && [ \"$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"
|
||||
|
|
@ -2172,61 +1939,5 @@ blink_darwin_arm64:
|
|||
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_powerpc64le_size
|
||||
blink_powerpc64le:
|
||||
.incbin "ape/blink-powerpc64le.gz"
|
||||
.endobj blink_powerpc64le,globl
|
||||
blink_powerpc64le_size = . - blink_powerpc64le
|
||||
.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
|
||||
|
||||
154
ape/ape.lds
154
ape/ape.lds
|
|
@ -611,160 +611,6 @@ HIDDEN(blink_darwin_arm64_size_b7 = blink_darwin_arm64_size < 10000000 ? 32 : bl
|
|||
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_powerpc64le_b0 = RVA(blink_powerpc64le) % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b1 = RVA(blink_powerpc64le) < 10 ? 32 : RVA(blink_powerpc64le) / 10 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b2 = RVA(blink_powerpc64le) < 100 ? 32 : RVA(blink_powerpc64le) / 100 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b3 = RVA(blink_powerpc64le) < 1000 ? 32 : RVA(blink_powerpc64le) / 1000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b4 = RVA(blink_powerpc64le) < 10000 ? 32 : RVA(blink_powerpc64le) / 10000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b5 = RVA(blink_powerpc64le) < 100000 ? 32 : RVA(blink_powerpc64le) / 100000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b6 = RVA(blink_powerpc64le) < 1000000 ? 32 : RVA(blink_powerpc64le) / 1000000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b7 = RVA(blink_powerpc64le) < 10000000 ? 32 : RVA(blink_powerpc64le) / 10000000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b8 = RVA(blink_powerpc64le) < 100000000 ? 32 : RVA(blink_powerpc64le) / 100000000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_b9 = RVA(blink_powerpc64le) < 1000000000 ? 32 : RVA(blink_powerpc64le) / 1000000000 % 10 + 48);
|
||||
|
||||
HIDDEN(blink_powerpc64le_size_b0 = blink_powerpc64le_size % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b1 = blink_powerpc64le_size < 10 ? 32 : blink_powerpc64le_size / 10 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b2 = blink_powerpc64le_size < 100 ? 32 : blink_powerpc64le_size / 100 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b3 = blink_powerpc64le_size < 1000 ? 32 : blink_powerpc64le_size / 1000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b4 = blink_powerpc64le_size < 10000 ? 32 : blink_powerpc64le_size / 10000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b5 = blink_powerpc64le_size < 100000 ? 32 : blink_powerpc64le_size / 100000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b6 = blink_powerpc64le_size < 1000000 ? 32 : blink_powerpc64le_size / 1000000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b7 = blink_powerpc64le_size < 10000000 ? 32 : blink_powerpc64le_size / 10000000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b8 = blink_powerpc64le_size < 100000000 ? 32 : blink_powerpc64le_size / 100000000 % 10 + 48);
|
||||
HIDDEN(blink_powerpc64le_size_b9 = blink_powerpc64le_size < 1000000000 ? 32 : blink_powerpc64le_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);
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue