Qual è il codice più breve per causare un overflow dello stack? [chiuso]

Per commemorare il lancio pubblico di StackTranslate.it, qual è il codice più corto per causare un overflow dello stack? Qualsiasi lingua benvenuta.

ETA: Giusto per essere chiari su questa domanda, visto che sono un utente occasionale di Scheme: la "ricorsione" di coda è davvero un'iterazione, e qualsiasi soluzione che può essere convertita in una soluzione iterativa in modo relativamente banale da un compilatore decente non lo farà essere contato. :-P

ETA2: ora ho selezionato una "migliore risposta"; vedi questo post per ragioni. Grazie a tutti quelli che hanno contribuito! :-)

Tutte queste risposte e nessun Befunge? Scommetterei una buona somma, è la soluzione più breve di tutte:

1

Non sto scherzando. Provalo tu stesso: http://www.quirkster.com/iano/js/befunge.html

EDIT: suppongo di dover spiegare questo. L'operando 1 inserisce un 1 nello stack interno di Befunge e la mancanza di qualsiasi altra cosa lo mette in loop secondo le regole della lingua.

Usando l'interprete fornito, alla fine - e intendo alla fine - colpire un punto in cui l'array Javascript che rappresenta lo stack di Befunge diventa troppo grande per essere riallocato dal browser. Se avessi un semplice interprete Befunge con uno stack più piccolo e limitato - come nel caso della maggior parte delle lingue sottostanti - questo programma causerebbe un overflow più evidente più veloce.

Leggi questa riga e fai ciò che dice due volte .

Puoi anche provare questo in C # .net

throw new StackOverflowException();

Nemerle :

Ciò provoca l'arresto anomalo del compilatore con StackOverflowException:

def o(){[o()]}

Il mio attuale migliore (nell'assemblaggio x86) è:

push eax
jmp short $-1

che risulta in 3 byte di codice oggetto ( 50 EB FD). Per il codice a 16 bit, questo è anche possibile:

call $

che risulta anche in 3 byte ( E8 FD FF).

PIC18

La risposta PIC18 fornita da TK risulta nelle seguenti istruzioni (binarie):

overflow
   PUSH
   0000 0000 0000 0101
   CALL overflow
   1110 1100 0000 0000
   0000 0000 0000 0000

Tuttavia, CALL da solo eseguirà un overflow dello stack:

CALL $
1110 1100 0000 0000
0000 0000 0000 0000

PIC18 più piccolo e più veloce

Ma RCALL (chiamata relativa) è ancora più piccolo (non memoria globale, quindi non è necessario per i 2 byte extra):

RCALL $
1101 1000 0000 0000

Quindi il più piccolo sul PIC18 è una singola istruzione, 16 bit (due byte). Ciò richiederebbe 2 cicli di istruzioni per loop. A 4 cicli di clock per ciclo di istruzioni hai 8 cicli di clock. Il PIC18 ha uno stack di 31 livelli, quindi dopo il 32 ° loop si sovrapporrà allo stack, in 256 cicli di clock. A 64 MHz, dovresti sovraccaricare lo stack in 4 micro secondi e 2 byte .

PIC16F5x (anche più piccolo e più veloce)

Tuttavia, la serie PIC16F5x utilizza istruzioni a 12 bit:

CALL $
1001 0000 0000

Ancora una volta, due cicli di istruzione per loop, 4 clock per istruzione, quindi 8 cicli di clock per loop.

Tuttavia, il PIC16F5x ha uno stack a due livelli, quindi sul terzo loop traboccerebbe, in 24 istruzioni. A 20 MHz, traboccerebbe in 1,2 micro secondi e 1,5 byte .

Intel 4004

L' Intel 4004 ha un'istruzione di subroutine di chiamata a 8 bit:

CALL $
0101 0000

Per i curiosi che corrispondono a un ascii 'P'. Con uno stack a 3 livelli che richiede 24 cicli di clock per un totale di 32,4 micro secondi e un byte . (A meno che non overclocki il tuo 4004 - dai, sai che vuoi farlo.)

Che è piccolo come la risposta befunge, ma molto, molto più veloce del codice befunge in esecuzione negli interpreti correnti.

C #:

public int Foo { get { return Foo; } }

Hoot overflow!

//              v___v
let rec f o = f(o);(o)
//             ['---']
//             -"---"-

Ogni attività ha bisogno dello strumento giusto. Scopri il linguaggio SO Overflow , ottimizzato per produrre stack overflow:

so

TeX:

\def~{~.}~

Risultati in:

! Capacità di TeX superata, scusa [dimensione dello stack di input = 5000].
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
~ -> ~
    .
...
<*> \ def ~ {~.} ~

LaTeX:

\end\end

Risultati in:

! Capacità di TeX superata, scusa [dimensione dello stack di input = 5000].
\ end # 1 -> \ csname end # 1
                      \ endcsname \ @checkend {# 1} \ expandafter \ endgroup \ if @ e ...
<*> \ end \ end

Assemblatore Z-80 - nella posizione di memoria 0x0000:

rst 00

un byte - 0xC7 - loop infinito di spingere il PC corrente nello stack e saltare all'indirizzo 0x0000.

In inglese:

recursion = n. See recursion.

Un altro esempio di PHP:

<?
require(__FILE__);

Che ne dici di quanto segue in BASIC:

10 GOSUB 10

(Non ho un interprete BASIC, temo, quindi è una supposizione).

Ho adorato la risposta di Cody, quindi ecco il mio contributo simile, in C ++:

template <int i>
class Overflow {
    typedef typename Overflow<i + 1>::type type;
};

typedef Overflow<0>::type Kaboom;

Non è una voce di codice golf in alcun modo, ma comunque, qualsiasi cosa per un overflow del meta stack! :-P

Ecco il mio contributo in C, del peso di 18 caratteri:

void o(){o();o();}

È molto più difficile ottimizzare la chiamata in coda! :-P

Utilizzando un file batch di una finestra chiamato "s.bat":

call s

Javascript

Per tagliare qualche altro personaggio e farci cacciare da più negozi di software, andiamo con:

eval(i='eval(i)');

Groovy:

main()

$ groovy stack.groovy:

Caught: java.lang.StackOverflowError
    at stack.main(stack.groovy)
    at stack.run(stack.groovy:1)
 ...

Per favore, dimmi cosa significa l'acronimo " GNU ".

Person JeffAtwood;
Person JoelSpolsky;
JeffAtwood.TalkTo(JoelSpolsky);

Speriamo in nessuna ricorsione della coda!

C - Non è il più corto, ma è privo di ricorsioni. Inoltre non è portatile: si arresta in modo anomalo su Solaris, ma alcune implementazioni alloca () potrebbero restituire un errore qui (o chiamare malloc ()). È necessaria la chiamata a printf ().

#include <stdio.h>
#include <alloca.h>
#include <sys/resource.h>
int main(int argc, char *argv[]) {
    struct rlimit rl = {0};
    getrlimit(RLIMIT_STACK, &rl);
    (void) alloca(rl.rlim_cur);
    printf("Goodbye, world\n");
    return 0;
}

perl in 12 caratteri:

$_=sub{&$_};&$_

bash in 10 caratteri (lo spazio nella funzione è importante):

i(){ i;};i

prova a mettere più di 4 polpette in un singolo hamburger. overflow dello stack.

Python :

so=lambda:so();so()

In alternativa:

def so():so()
so()

E se la coda ottimizzata di Python chiama ...:

o=lambda:map(o,o());o()

Sto selezionando la "migliore risposta" dopo questo post. Ma prima, vorrei riconoscere alcuni contributi molto originali:

1. quelli di Aku. Ognuno esplora un modo nuovo e originale di causare lo straripamento dello stack. L'idea di fare f (x) ⇒ f (f (x)) è una che esplorerò nella prossima voce, di seguito. :-)
2. Quello di Cody che ha dato al compilatore Nemerle un overflow dello stack.
3. E (un po 'a malincuore), quello di GateKiller sul lancio di un'eccezione di overflow dello stack. :-P

Per quanto adoro quanto sopra, la sfida riguarda il code golf e, per essere onesti con gli intervistati, devo assegnare la "migliore risposta" al codice più corto, che è la voce Befunge; Non credo che nessuno sarà in grado di batterlo (anche se Konrad ha sicuramente provato), quindi congratulazioni Patrick!

Vedendo il gran numero di soluzioni stack-overflow-by-recursion, sono sorpreso che nessuno (al momento della stesura attuale) abbia sollevato il combinatore Y (vedi il saggio di Dick Gabriel, Il perché di Y , per un primer). Ho una soluzione ricorsiva che utilizza il combinatore Y, nonché l'approccio aku f (f (x)). :-)

((Y (lambda (f) (lambda (x) (f (f x))))) #f)

Ecco un altro interessante di Scheme:

((lambda (x) (xx)) (lambda (x) (xx)))

Giava

Versione leggermente più breve della soluzione Java.

class X{public static void main(String[]a){main(a);}}

xor esp, esp
ret

3 byte:

label:
  pusha
  jmp label

Aggiornare

Secondo la (vecchia?) Documentazione Intel (?) , Si tratta anche di 3 byte:

label:
  call label