Fragment de code machine x86 32 bits, 1 octet
48 dec eax
Entrée dans EAX, sortie dans EAX: 0 pour vrai, non nul pour faux. (Laisse également le drapeau ZF défini sur true, non défini sur false, afin que vous puissiez je was_equal). En "bonus", vous n'avez pas à vous soucier de l'emballage; Le x86 32 bits ne peut traiter que 4 Go de mémoire, vous ne pouvez donc pas faire M assez grand pour envelopper tout autour et trouver 1 == 2**32 + 1ou quelque chose.
Pour créer une fonction appelable, ajoutez une 0xC3 retinstruction après avoir répété 0x48M fois. (Non compté dans le nombre total, car de nombreuses langues doivent répéter uniquement le corps de la fonction ou une expression pour pouvoir rivaliser).
Appelable depuis GNU C avec l' attribut de fonction x86 du prototype __attribute__((regparm(1))) int checkeqM(int eax); GNU Cregparm , comme -mregparm, utilise EAX pour passer le premier argument entier.
Par exemple, ce programme complet prend 2 arguments, et JITs M copies de l'instruction + a retdans un tampon, puis l'appelle en tant que fonction. (Nécessite un tas exécutable; compiler avec gcc -O3 -m32 -z execstack)
/******* Test harness: JIT into a buffer and call it ******/
// compile with gcc -O3 -no-pie -fno-pie -m32 -z execstack
// or use mprotect or VirtualProtect instead of -z execstack
// or mmap(PROT_EXEC|PROT_READ|PROT_WRITE) instead of malloc
// declare a function pointer to a regparm=1 function
// The special calling convention applies to this function-pointer only
// So main() can still get its args properly, and call libc functions.
// unlike if you compile with -mregparm=1
typedef int __attribute__((regparm(1))) (*eax_arg_funcptr_t)(unsigned arg);
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int main(int argc, char *argv[])
{
if (argc<3) return -1;
unsigned N=strtoul(argv[1], NULL, 0), M = strtoul(argv[2], NULL, 0);
char *execbuf = malloc(M+1); // no error checking
memset(execbuf, 0x48, M); // times M dec eax
execbuf[M] = 0xC3; // ret
// Tell GCC we're about to run this data as code. x86 has coherent I-cache,
// but this also stops optimization from removing these as dead stores.
__builtin___clear_cache (execbuf, execbuf+M+1);
// asm("" ::: "memory"); // compiler memory barrier works too.
eax_arg_funcptr_t execfunc = (eax_arg_funcptr_t) execbuf;
int res = execfunc(N);
printf("%u == %u => %d\n", N,M, res );
return !!res; // exit status only takes the low 8 bits of return value
}
les exécutables non PIE sont chargés plus bas dans la mémoire virtuelle; peut faire un plus grand malloc contigu.
$ gcc -g -O3 -m32 -no-pie -fno-pie -fno-plt -z execstack coderepeat-i386.c
$ time ./a.out 2747483748 2747483748 # 2^31 + 600000100 is close to as big as we can allocate successfully
2747483748 == 2747483748 => 0
real 0m1.590s # on a 3.9GHz Skylake with DDR4-2666
user 0m0.831s
sys 0m0.755s
$ echo $?
0
# perf stat output:
670,816 page-faults # 0.418 M/sec
6,235,285,157 cycles # 3.885 GHz
5,370,142,756 instructions # 0.86 insn per cycle
Notez que GNU C ne supporte pas les objets de tailles plus grand que ptrdiff_t(signé 32 bits), mais mallocet memsetfaire encore du travail, de sorte que ce programme réussisse.
Fragment de code machine ARM Thumb, 2 octets
3802 subs r0, #2
Le premier argument r0et la valeur de retour dans r0est la convention d'appel ARM standard. Cela définit également des indicateurs (le ssuffixe). Fait amusant; la version sans réglage de drapeau subest une instruction large de 32 bits.
L'instruction de retour que vous devez ajouter est bx lr.
Fragment de code machine AArch64, 4 octets
d1001000 sub x0, x0, #0x4
Fonctionne pour les entiers 64 bits. Entrée / sortie dans x0, selon la convention d'appel standard. int64_t foo(uint64_t);
AArch64 n'a pas (encore) de mode Thumb, donc 1 instruction est la meilleure que nous puissions faire.
Lconcaténée après lui-mêmeMdevrait renvoyer si son entréeNest égale àL*M?