fragmento de código de máquina x86 de 32 bits, 1 byte
48 dec eax
Entrada no EAX, saída no EAX: 0 para true, diferente de zero para false. (Também deixa o sinalizador ZF definido como verdadeiro, não definido como falso, para que você possaje was_equal ). Como um "bônus", você não precisa se preocupar com a embalagem; O x86 de 32 bits pode endereçar apenas 4GiB de memória, então você não pode fazer M grande o suficiente para envolver e encontrar 1 == 2**32 + 1algo assim.
Para criar uma função que pode ser chamada, anexe um 0xC3 ret instrução após repetir 0x48M vezes. (Não é contado na contagem total, porque muitas linguagens precisam repetir apenas o corpo da função, ou uma expressão, para poder competir).
Pode ser chamado do GNU C com o atributo de função x86 do protótipo __attribute__((regparm(1))) int checkeqM(int eax); GNU Cregparm , como -mregparm, usa EAX para passar o primeiro argumento inteiro.
Por exemplo, este programa completo leva 2 args e JITs M copia a instrução + a retem um buffer e a chama como uma função. (Requer heap executável; compile com 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
}
os executáveis não PIE são carregados mais baixo na memória virtual; pode fazer um malloc contíguo maior.
$ 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
Note-se que GNU C não suporta objeto tamanhos maiores do que ptrdiff_t(assinado de 32 bits), mas malloce memsetfazer ainda trabalho, então este programa bem-sucedido.
Fragmento de código de máquina ARM Thumb, 2 bytes
3802 subs r0, #2
O primeiro argumento de entrada r0e o valor de retorno r0é a convenção de chamada padrão do ARM. Isso também define sinalizadores (o ssufixo). Fato engraçado; o não versão de definição de -flag de subuma instrução de largura de 32 bits.
A instrução de retorno que você precisa anexar é bx lr .
Fragmento de código de máquina AArch64, 4 bytes
d1001000 sub x0, x0, #0x4
Funciona para números inteiros de 64 bits. Entrada / saída emx0 , conforme a convenção de chamada padrão. int64_t foo(uint64_t);
O AArch64 ainda não possui o modo Thumb, portanto, 1 instrução é a melhor que podemos fazer.
Lconcatenado após oMtempo deve retornar se sua entradaNé igual aL*M?