Tulis kode legal yang sempurna dalam bahasa pilihan Anda yang kompilasi akan membuat crash kompilator atau mengirimkannya ke infinite loop (waktu kompilasi tak terbatas).

Pembatasan:

• Gunakan bahasa standar yang digunakan di dunia nyata.
• Gunakan kompiler standar yang dikembangkan dengan baik (tidak ada jawaban seperti "Saya menulis kompiler C saya yang macet dalam segala hal").
• Kode harus legal dalam bahasa (jadi kemungkinan besar Anda harus mengeksploitasi kompiler atau bug bahasa).
• Berikan versi kompiler Anda dan opsi yang digunakan sehingga orang lain dapat menggandakannya.
• Jelaskan mengapa kompiler macet, jika mungkin.

Selamat bersenang-senang :)

Saya cukup yakin itu sudah diperbaiki sekarang, tetapi dulu Anda bisa membuat crash compiler Java (atau, crash Eclipse) dengan menulis

class Foo {
  static double d = 2.2250738585072012e-308;
}

http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308/

Sebenarnya, menurut halaman itu, kompiler hanya akan hang, bukan crash. Tetap saja, saya pikir itu cukup menyenangkan.

Solusi favorit saya untuk GHC:

data Bad a = C (Bad a -> a)

xx :: Bad a -> a
xx (x@(C x')) = x' x

omega :: a
omega = xx (C xx)

main = omega

Untuk GHC 6.12.1 keduanya ghci Bad.hsdan ghc Bad.hsloop tanpa batas. GHC 7.4.1 loop tanpa batas ketika ghc -O2 Bad.hsdijalankan.

Penjelasan: omega didefinisikan menggunakan rekursi tak terbatas (satu-satunya cara ia dapat menghuni jenis apa pun). Inliner kompiler melihat xxsebagai fungsi sederhana, non-rekursif, jadi ia mencoba untuk menyelaraskannya dalam definisi omega. Ini menghasilkan (\x@(C x') -> x' x) (C xx). Melihat kecocokan pola pada konstruktor, kompiler mencoba menguranginya, mendapatkan xx (C xx)lagi, dan mengulang. Kuncinya adalah yang xxsebenarnya rekursif, tetapi rekursi tersembunyi dalam tipe data.

Catatan: Saat menulis puzzle, saya lupa saya membiarkan GHC berjalan di loop yang tak terbatas. Butuh semua memori saya, crash Firefox dan saya nyaris tidak berhasil membunuhnya tanpa hard reset.

Ini mudah dalam bahasa yang diketik secara dependen . Tipe-pengecekan tipe dependen umum tidak dapat ditentukan karena mungkin memerlukan perhitungan kompleks yang arbitrari (Turing-complete). Anda cukup menyandikan dalam tipe dependen nilai terlalu besar. Kemudian pemeriksa tipe akan menggunakan semua memori yang tersedia dan crash. Sebagai contoh, dalam Coq, ReyCharles memberikan contohCompute 70000. , yang menyebabkan pemeriksa tipe membangun angka Peano raksasa dan crash.

Dalam bahasa yang lebih umum yang mendukung semacam ekspansi makro atau pemrograman, Anda dapat melakukan hal serupa. Misalnya, Anda dapat menggunakan semua memori yang tersedia di C:

#include <stdio.h>
#define a printf("%s", "Hello, world!\n");
#define b a a a a a a a a a a a a a a a a
#define c b b b b b b b b b b b b b b b b
#define d c c c c c c c c c c c c c c c c
#define e d d d d d d d d d d d d d d d d
#define f e e e e e e e e e e e e e e e e
// ...
#define z y y y y y y y y y y y y y y y y
int main() { z }

Bahasa pemrograman D memungkinkan eksekusi fungsi waktu kompilasi . Ini dapat digunakan untuk menghitung sesuatu pada waktu kompilasi yang terlalu besar untuk muat dalam memori. Sesuatu yang serupa dapat dicapai dengan menggunakan metaprogramming template C ++.

Dalam XML (bukan bahasa pemrograman yang dikompilasi, tetapi prosesor XML analog dengan kompiler), entitas yang berkembang dapat membuat prosesor kehabisan memori:

<?xml version="1.0"?>
<!DOCTYPE lolz [
 <!ENTITY lol "lol">
 <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
 <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
 <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
...
]>
<lolz>&lol999;</lolz>

Ini disebut serangan tertawa milyaran .

C #

Menemukan ini di pertanyaan stackoverflow :

using System;
using System.Linq;

public class Test
{
    public static void Main()
    {
        Enumerable.Range(0, 1).Sum(a =>
        Enumerable.Range(0, 1).Sum(b =>
        Enumerable.Range(0, 1).Sum(c =>
        Enumerable.Range(0, 1).Sum(d =>
        Enumerable.Range(0, 1).Sum(e =>
        Enumerable.Range(0, 1).Sum(f =>
        Enumerable.Range(0, 1).Count(g => true)))))));
    }
}

Kompiler pada akhirnya akan macet.

Masalah ini tampaknya terkait dengan inferensi tipe dan / atau generasi lambda dikombinasikan dengan resolusi kelebihan.

VBA

bagaimana kalau Anda bisa crash IDE dengan mengetikkan kode?

di aplikasi Microsoft Office apa pun, coba ini:

ALT+ F11untuk membuka jendela VBA, lalu coba kode berikut

sub foo()
dim v(1 to 3, 1 to 3)
redim preserve v(,1 to 5)

dan lihat:

Anda cukup mengetik redim preserve v(,1 to 5)ke jendela langsung, dan itu akan macet setelah Anda menekan ENTER!

Perl (15)

BEGIN{1while 1}

Ini menciptakan loop tak terbatas pada waktu kompilasi :

Blok kode BEGIN dijalankan sesegera mungkin, yaitu saat ditentukan sepenuhnya, bahkan sebelum sisa file yang berisi (atau string) diuraikan.

(dari perlmod )

Dan itu sebabnya Perl tidak dapat menyelesaikan parsing kode. Ini tidak berakhir:

$ perl -MO=Deparse -e 'BEGIN{1while 1}'

J

Segfaults juru bahasa J (setidaknya di Linux):

15!:1[3#2

Mencoba membaca dari alamat memori 2. Menariknya, jika Anda mencobanya dengan 0 atau 1, Anda dapatkan domain error.

TeX

\def\x{\x}\x

TeX adalah bahasa ekspansi makro. Di sini kami mendefinisikan ekspansi makro \xmenjadi \xlagi, dan kemudian kami menambahkan setelah doa \x. TeX terjebak tanpa henti mengganti \xdengan \x.

Skema

(define-syntax s
    (syntax-rules ()
        ((_ (t) ...) (s (t t) ... (t t) ...))
        ((_ (t u) ...) (s (t) ... (u) ...))))
(s (+))

Kompiler saya, Chicken, membuat kesalahan dengan mencoba memperluas makro pada waktu kompilasi untuk "kinerja run-time" atau sesuatu. Jadi itu membayar harga ekspansi yang satu ini. Saya sudah membaca R5RS. Tidak ada yang mengatakan makro harus diperluas pada waktu kompilasi.

Pada dasarnya apa yang terjadi adalah makro memperluas ekspresi ukuran tak terbatas, terus-menerus menggandakan ukuran. Nah, untuk teknis, menggandakan setiap ekspansi lainnya. Nasib kompilator tersegel. Setidaknya pada sistem saya, tutup Ayam di 2GB, kios untuk waktu yang lama mencoba mengumpulkan sampah, lalu macet setelah pengumpul sampah menyerah. Memang butuh beberapa saat karena semua keajaiban higienis yang mahal secara komputasi terjadi.

Beralih di antara ekspresi bentuk

(s (+) (+) (+) (+) ....

dan

(s (+ +) (+ +) (+ +) (+ +) ....

tampaknya sangat, sangat dramatis meningkatkan tingkat konsumsi memori dibandingkan dengan:

(define-syntax s
    (syntax-rules ()
        ((_ t ...) (s t ... t ...))))
(s +)

Saya menduga Chicken adalah kompiler yang cukup tangguh yang memiliki beberapa cara untuk menghindari analisis mendalam dari ekspresi sintaksis ketika bisa lolos begitu saja, tetapi solusi terakhir saya memaksa pencocokan pola untuk benar-benar menyelam.

Gangguan umum

Makro membuatnya mudah:

(defmacro loop-forever ()
  (loop for x from 0 collecting x))

(defun compile-me ()
  (loop-forever))

Mengkompilasi compile-mepanggilan loop-forever, yang menghabiskan memori tumpukan selama ekspansi dan membuat crash kompilator. Jika Anda hanya ingin membuat kompiler digantung tanpa batas waktu, maka definisi ini loop-foreverakan melakukannya:

(defmacro loop-forever ()
  (loop))

Ini harus bekerja menggunakan implementasi CL apa pun, kecuali jika Anda sangat pintar dan dapat mendeteksi loop tak terbatas sederhana, tapi saya sangat ragu ada yang melakukan ini. Perlindungan penuh terhadap ini tidak mungkin, tentu saja.

PHP 5.3.1 (Interpreter Segfaults) ( Bug 50261 , diperbaiki pada 5.3.3)

   kelas testClass
   {
       fungsi testClass ()
       {
           gema 'Keluaran string!';
       }
   }

   kelas testClass2 memperluas testClass
   {
       function __construct ()
       {
           call_user_func (array ('parent', '__construct'));
       }
   }

   testClass2 baru;

Yang ini sedikit masalah, karena kode di atas adalah umum dalam banyak kode yang saya kerjakan, membuat ini masalah yang cukup luas bagi kami.

(Jika saya ingat dengan benar, pada satu titik ini adalah satu-satunya cara untuk memanggil konstruktor induk dalam PHP.)

D

(DMD32 D Compiler v2.067.1, Windows build)

enum x = "mixin(x);";
mixin(x);

Perhatikan bahwa ini akan mengirim kompiler ke loop infinite dan crash.

Kesalahan: kehabisan memori

Mekanik siput menunjukkan bahwa fitur pemrograman waktu kompilasi dalam D dapat disalahgunakan untuk tujuan ini, tetapi solusinya mungkin lebih sederhana daripada jenis teknik yang ada dalam pikirannya.

Bagi mereka yang tidak terbiasa dengan 'string mixin', ini adalah fitur makro yang cukup mudah. Ketika kompilator bertemu mixin("asdf"), itu menggantikannya dengan isi string asdf,, dan mencoba untuk mengkompilasinya lagi.

Solusi di atas akan diperluas seperti:

mixin(x);  ->  mixin("mixin(x);");  ->  mixin(x);

Jadi kecuali jika kompiler mencoba untuk mendeteksi kasus ekspansi-ke-yang sama ini, ia akan memasuki loop ekspansi tanpa batas.

Perl

Ini mendefinisikan operator kelebihan pada waktu kompilasi, dan menjalankan kode pada waktu kompilasi yang menambahkan instance kelas bersama-sama.

(Omong-omong, rekursi yang biasanya tak terbatas akan memakan semua memori, tetapi dengan kelebihan beban, itu hanya crash)

package MyAmazingClass;
use 5.010;

use overload '+' => sub {
    my ($first, $second) = @_;
    return $first + $second;
};

sub new {
    my $self = shift;
    return bless {}, $self;
}

# BEGIN runs code at compile time
BEGIN {
    my $instance = MyAmazingClass->new;
    my $sum = $instance + $instance;
    say $sum;
}

Keluaran:

fish: Job 1, 'perl' terminated by signal SIGSEGV (Address boundary error)

Simplex v.0.5 , 2 byte

Sayang sekali ini bukan kode-golf :

2Q

Biarkan saya jelaskan. Dari dokumen:

[ Q] Menambahkan kode sumber program ke program luar, dari awal (tidak termasuk! Karakter, jika byte saat ini tidak nol) Jika byte adalah 2, duplikat perintah saat ini juga.

Begitu:

2 ~~ Manhattan adds 2 to the current byte: 10*0 + 2 = 2.
Q ~~ Adds program source code to the outer program, with Q

Program luar adalah fitur kecil yang rapi di Simplex: itu dievaluasi pada akhir program. Jadi, jika kita terus melacak ...:

P1  P2  P3  P4  ...
2Q->2Q->2Q->2Q->...

Akhirnya, memori akan habis dan dunia akan berakhir.

Dentang ++

Saya baru saja menemukan bug yang menyenangkan ini.

#include <iostream>
#include <string>
#include <sstream>
#include <fstream>

std::stringstream prog;

constexpr unsigned c_strlen( char const* str, unsigned count = 0 )
{
    return ('\0' == str[0]) ? count : c_strlen(str+1, count+1);
}

template < char t_c, char... tt_c >
struct rec_eval
{
    static void eval()
    {
        rec_eval<t_c>::eval();
        rec_eval < tt_c... > :: eval ();
    }
};
template < char t_c >
struct rec_eval < t_c >
{
    static void eval() {
        switch(t_c) {
            case '+':
                prog<<"++t[i];";
                break;
            case '-':
                prog<<"--t[i];";
                break;
            case '>':
                prog<<"++i;";
                break;
            case '<':
                prog<<"--i;";
                break;
            case '[':
                prog<<"while(t[i]){";
                break;
            case ']':
                prog<<"}";
                break;
            case '.':
                prog<<"putc(t[i],stdout);";
                break;
            case ',':
                prog<<"t[i]=getchar();";
                break;
        }
    }
};

template < char... tt_c >
struct exploded_string
{
    static void eval()
    {
        rec_eval < tt_c... > :: eval();
    }
};
template < typename T_StrProvider, unsigned t_len, char... tt_c >
struct explode_impl
{
    using result =
        typename explode_impl < T_StrProvider, t_len-1,
                                T_StrProvider::str()[t_len-1],
                                tt_c... > :: result;
};

template < typename T_StrProvider, char... tt_c >
struct explode_impl < T_StrProvider, 0, tt_c... >
{
     using result = exploded_string < tt_c... >;
};

template < typename T_StrProvider >
using explode =
    typename explode_impl < T_StrProvider,
                            c_strlen(T_StrProvider::str()) > :: result;


int main(int argc, char** argv)
{
    if(argc < 2) return 1;
    prog << "#include <stdio.h>\n#include <stdlib.h>\nint main(){unsigned char* t=calloc(";
    prog << (1 << sizeof(unsigned short));
    prog << ",sizeof(unsigned short));unsigned short i=0;";

    struct my_str_provider
    {
        constexpr static char const* str() { return "++++[>+++++<-]>+++[[>+>+<<-]>++++++[<+>-]+++++++++[<++++++++++>-]>[<+>-]<-]+++>+++++++++[<+++++++++>-]>++++++[<++++++++>-]<--[>+>+<<-]>>[<<+>>-]<-->>++++[<++++++++>-]++++++++++>+++++++++[>+++++++++++<-]>[[>+>+>+<<<-]>[<+>-]>>[[>+>+<<-]>>[<<+>>-]<[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<<<+>---------->->[-]]]]]]]]]]]<]<<[>>++++++++++++[<++++<++++>>-]<<[.[-]>]<<]>[<++++++[>++++++++<-]>.[-]]<<<<<.<<<<<.[<]>>>>>>>>>.<<<<<..>>>>>>>>.>>>>>>>.[>]>[>+>+<<-]>[<+>-]>[-[[-]+++++++++[<+++++++++++++>-]<--.[-]>]]<<<<<.[<]>>>>>>>>>.>>>>>>>>>.[>]<<.<<<<<.<<<..[<]>>>>>>.[>]<<.[<]>>>>>>>>>.>.[>]<<.[<]>>>>.>>>>>>>>>>>>.>>>.[>]<<.[<]>.[>]<<<<<<.<<<<<<<<<<<..[>]<<<.>.[>]>[>+>+>+<<<-]>[<+>-]>>[[>+>+<<-]>>[<<+>>-]<[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<<<+>---------->->[-]]]]]]]]]]]<]<<[>>++++++++++++[<++++<++++>>-]<<[.[-]>]<<]>[<++++++[>++++++++<-]>.[-]]<<<<<.<<<<<.[<]>>>>>>>>>.<<<<<..>>>>>>>>.>>>>>>>.[>]>[>+>+<<-]>[<+>-]>[-[[-]+++++++++[<+++++++++++++>-]<--.[-]>]]<<<<<.[<]>>>>>>>>>.>>>>>>>>>.[>]<<.<<<<<.<<<..[<]>>>>>>.[>]<<<<.>>>.<<<<.<.<<<<<<<<<<.>>>>>>.[>]<<.[<]>>>>>>>>>.>.>>>>>>>>>.[>]<<.<<<<<<<.[<]>>>>>>>>>.[<]>.>>>>>>>>>.[>]<<.<<<<.<<<<<<<<<<<<<.[>]<<<<<<<<<.[>]<<.[<]>>>>>>>>.[>]<<<<<<.[<]>>>>>..[>]<<.<<<<<<<<<<<<.[<]>>>>.[>]<<.<<<<.[<]>>>>>>.>>>.<<<<<<.>>>>>>>.>>>>>>>>>>.[>]<<<.>.>>>-[>+>+>+<<<-]>[<+>-]>>[[>+>+<<-]>>[<<+>>-]<[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<->-[<<<+>---------->->[-]]]]]]]]]]]<]<<[>>++++++++++++[<++++<++++>>-]<<[.[-]>]<<]>[<++++++[>++++++++<-]>.[-]]<<[>+>+<<-]>[<+>-]+>[<->[-]]<[-<<<[<]>>>>>>>>>>.<.[>]<<.[<]>>>>>>>>>>>.<<.<<<.[>]<<<<<<<<<<.[>]>>]<<<<.<<<<<.[<]>>>>>>>>>.<<<<<..>>>>>>>>.>>>>>>>.[>]>[>+>+<<-]>[<+>-]+>[<->-[<+>[-]]]<[++++++++[>+++++++++++++<-]>--.[-]<]<<<<.[<]>>>>>>>>>.>>>>>>>>>.[>]<<.<<<<<.<<<..[<]>>>>>>.[>]<<.[<]>>>>>>>>>.>.[>]<<.[<]>>>>.>>>>>>>>>>>>.>>>.[>]<<.[<]>.[>]<<<<<<.<<<<<<<<<<<..[>]<<<<.>>>..>>]"; }
    };

    auto my_str = explode < my_str_provider >{};
    my_str.eval();

    prog << "}";

    std::ofstream ofs(argv[1]);
    if(!ofs) return 2;
    ofs << prog.str() << std::endl;
    ofs.close();

    return 0;
}

Tujuannya adalah untuk menerjemahkan Brainfuck ke dalam C, menggunakan template meta-programming untuk melakukan sebagian besar pekerjaan. Kode ini berfungsi untuk program Brainfuck yang lebih kecil, seperti Hello World, tetapi ketika saya mencoba menjalankannya dengan 99 Botol ...

$ clang++ -std=c++11 -fconstexpr-depth=1000 bf_static.cpp
clang: error: unable to execute command: Segmentation fault (core dumped)
clang: error: clang frontend command failed due to signal (use -v to see invocation)
clang version 3.5.2 (tags/RELEASE_352/final)
Target: i386-pc-windows-cygnus
Thread model: posix
clang: note: diagnostic msg: PLEASE submit a bug report to http://llvm.org/bugs/ and include the crash backtrace, preprocessed source, and associated run script.
clang: note: diagnostic msg:
********************

PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:
Preprocessed source(s) and associated run script(s) are located at:
clang: note: diagnostic msg: /tmp/bf_static-afa982.cpp
clang: note: diagnostic msg: /tmp/bf_static-afa982.sh
clang: note: diagnostic msg:

********************

Ini akan berhasil dikompilasi dalam GCC (setelah sekitar 2 menit), tetapi menautkannya menyebabkan masalah lain ...

/usr/lib/gcc/i686-pc-cygwin/4.9.3/../../../../i686-pc-cygwin/bin/as: /tmp/cc0W7cJu.o: 
section .eh_frame$_ZN8rec_eval<giant mangled name removed>: string table overflow at offset 10004228
/tmp/cc3JeiMp.s: Assembler messages:
/tmp/cc3JeiMp.s: Fatal error: can't close /tmp/cc0W7cJu.o: File too big

Ups.

Smalltalk (Dialek mencicit, versi 4.x)

Sangat mudah, cukup evaluasi ini, atau terima metode dengan literal ini

1.0e99999999999999999999

Ini akan mencoba untuk mengevaluasi kekuatan 10 dalam aritmatika Bilangan Besar, hanya untuk pembulatan inf Tsss;)

Sunting: berapa banyak 9 yang diperlukan?

Karena 2 ^ 10 adalah 1024, kira-kira 10 ^ 3, kita dapat memperkirakan sekitar 10 ^ n x 2 ^ (10 * n / 3). Itu berarti bahwa 10 ^ n membutuhkan 10 * n / 3 bit untuk direpresentasikan dalam biner. Kami ingin agar 10 tidak dapat diwakili.

Dengan asumsi pointer 32 bit untuk memori objek, kita tahu bahwa kita tidak dapat mengatasi lebih dari 2 ^ 32 byte, yaitu 2 ^ 35 bit. Jadi mari kita balikkan masalahnya: 2 ^ 35 kira-kira 32 * 2 ^ 30, 32 * 10 ^ 9. Itu membutuhkan sekitar 11 angka desimal, jadi dengan sebelas 9, kami yakin akan menghasilkan kesalahan pada mencicit 32bit. Dalam 64 bit itu akan menjadi dua puluh satu 9.

Kita juga dapat menghabiskan memori dengan 9s lebih sedikit, seluruh ruang yang dapat dialamatkan belum tentu tersedia, tetapi sangat lambat untuk diuji, Squeak VM tidak dioptimalkan untuk aritmatika raksasa seperti GMP.

Ini adalah metode asli dan ringkas saya untuk membuat crash GolfScript:

{1.}do

Apa yang dilakukan adalah mengatur loop selamanya yang terus mendorong 1 ke tumpukan sampai memori habis.

Dalam C / C ++, saya percaya bahwa potongan kode asli ini akan membuat crash kompilator:

#define a bb
#define b aa
int main(){a}

Ini akan membuat kompiler macet menggandakan jumlah a dan mengubahnya menjadi b's dan sebaliknya, sehingga kompiler akan segera kehabisan memori dan crash.

Satu lagi adalah untuk batch pada Windows, jika benar-benar membekukan komputer daripada hanya script batch itu sendiri yang diperhitungkan. Anda harus mengetikkan yang berikut:

:a
start %0
goto a

Ini masuk ke lingkaran tak terbatas membuat salinan sendiri, yang membuat salinan diri mereka sendiri dan seterusnya. Ini kemungkinan besar pada akhirnya akan merusak komputer Anda jika Anda menjalankan sedikit kode ini.

Yang terakhir adalah bom VBS. Ini adalah bom lain, seperti yang terakhir, tetapi malah membuka kotak dialog dalam jumlah tak terbatas.

set oshell = wscript.createobject("wscript.shell")
do
oshell.run "wscript " & wscript.scriptname
msgbox "blah"
loop

Ini secara terus-menerus membuat salinan dirinya sendiri dan membuka kotak pesan dalam loop tak terbatas, yang juga dilakukan oleh klon. Menjalankan dua program terakhir ini tidak dianjurkan, karena mereka dapat membekukan komputer Anda dan menyebabkan Anda harus mem-boot komputer Anda.

Perhatikan bahwa saya membuat sendiri semua program ini.

Gangguan Umum, 8 byte

Lebih pendek dari jawaban Common Lisp lainnya :-)

#.(loop)

Ulangi saat membaca formulir Anda.

Standar Common Lisp tidak menyebutkan cara portabel untuk membuatnya crash, jadi saya kira kita perlu memiliki cara yang ditentukan implementasi. Masih 8 byte:

#.(quit) ; ccl

... atau,

#.(exit) ; sbcl

Saat Anda menelepon (compile-file "crash.lisp"), lingkungan secara misterius "macet".

Bercanda terpisah, saya masih berusaha menemukan cara untuk benar-benar merusak lingkungan (dan sebentar lagi), tetapi itu sangat sulit. Yang saya dapatkan adalah interaksi yang bagus dengan debugger.

x86 asm

"nasm -v" mengembalikan "NASM versi 2.11.08 dikompilasi pada 21 Feb 2015" (Saya menjalankannya di bawah win7)

Assembler telah berjalan untuk 1:12:27 sejauh ini pada i7, benar-benar jenuh salah satu core. File output duduk pada 0 byte, konsumsi memori telah stabil pada 1.004K - tampaknya aman untuk mengatakan saya sudah dipukuli habis-habisan, daripada hanya memberikannya tugas yang sangat, sangat lama. :)

Kunci triknya adalah nilai repeat di makro - 0xFFFFFFFF. Meski begitu, aku tidak cukup akrab dengan bagian dalam Nasm untuk mengetahui mengapa sebenarnya hal ini membuatku tercekik. Saya berharap untuk mendapatkan output ~ 16GB satu jam yang lalu.

%MACRO INVOKE 1-*
;  %REP    %0 - 1
  %REP     0xffffffff
    %ROTATE   -1
    PUSH    DWORD %1
  %ENDREP
  %ROTATE -1
  CALL    %1
%ENDMACRO

[section .text]
bits 32
org 0x10000

EntryPoint:
    INVOKE dword 666
    ret

EDIT: Baru saja memeriksa task manager, Nasm telah berjalan selama 7:40:41 dan memori sekarang mencapai 1.016K

Gnu assembler, menghasilkan file keluaran besar

Makro ini berupaya mengisi file keluaran dengan sampah (biasanya nol byte) hingga batas 4 GB tercapai, menambahkan int untuk melewati batas itu, dan secara rekursif memanggil dirinya sendiri untuk tetap mengisi output dengan potongan sampah 4 GB. Ini akan mengisi hard drive Anda sampai penuh, pada titik mana assembler kemungkinan akan crash.

.macro f n #Define a macro named f, taking argument n.
.p2align 32 #Fill file with 0x00's until current address is divisible by 2^32
.long 0 #Add a long after the current address, throwing it off alignment.
.if \n #If n > 0, recursively tail-call itself, decrementing n.
f "(\n-1)"
.endif
.endm #End macro definition.
f 32 #Expand macro f, with n = 32 (output size 4GB*32 = 128GB)

Perhatikan bahwa rekursi tak terbatas tidak dapat digunakan, karena assembler akan menangkap kasing khusus itu dan berhenti memperluas makro.

Kompilasi dapat dilakukan dengan as -o crash.out crash.ssebagian besar distribusi Linux.

Gangguan Umum, 29 byte

Implementasi: Clozure CL

PERINGATAN: Hati-hati saat menjalankan kode ini, ini dapat mematikan proses yang tidak Anda inginkan!

#.(run-program"pkill"'("cl"))

Ini menjalankan perintah shell pkill clpada waktu kompilasi, yang akan membunuh proses Lisp melakukan kompilasi. Secara teknis tidak crash, tetapi memiliki efek yang sama.

Contoh penggunaan:

$ cat /tmp/t.lisp
#.(run-program "pkill" '("cl"))
$ ccl -n
Welcome to Clozure Common Lisp Version 1.11-dev-r16513-trunk  (LinuxX8664)!

? (compile-file "/tmp/t.lisp")
#P"/tmp/t.lx64fsl"
NIL
NIL
?
zsh: terminated  ccl -n
$ 

Felix

Ini tidak berfungsi lagi, tetapi pada satu titik, kode ini:

include "std/control/pchannels";

fun is_square(v: int) => let s = int$ sqrt$ v.float + 0.5f in s*s == v;
fun is_median(v: int) => v % 4 == 0 and (v/4).is_square;

struct Message { value: int; };

proc process(c: int, chan: pchannel[Message]) {
    var i = 0;
    for var b in (c+1)/2 upto c do
        for var a in c - b + 1 upto b do
            if is_median(2*(b*b+c*c)-a*a) or
               is_median(2*(a*a+c*c)-b*b) or
               is_median(2*(a*a+b*b)-c*c) do ++i; done;
        done
    done
    write(chan, Message i);
};

proc main() {
    n := int$ System::argv 1;
    var count = n;
    chan := #mk_pchannel[Message];
    var ntri = 0;

    for var c in 1 upto n perform spawn_pthread { process(c, chan); };

    while count > 0 do
        let v = chan.read in ntri += v.value;
        --count;
    done
    ntri.println;
}

main;

Ini akan memberikan kesalahan besar:

inner_bind_expression raised Not_found [BUG] e=(&((main_mf_60270<60270> ())), (value v))

SISTEM KEGAGALAN bind_expression 'mengangkat Not_found [BUG] Kompilasi Felix "/ media / ryan / stuff / felix / build / release / host / bin / flxg" "-q" "--optimise" "--inline = 100" "- - output_dir = / home / ryan / stuff / .felix / text "" --cache_dir = / home / ryan / stuff / .felix / cache "" -I / media / ryan / stuff / felix / build / release / share / lib "" -I / media / ryan / stuff / felix / build / release / host / lib "" --syntax=@/media/ryan/stuff/felix/build/release/share/lib/grammar/grammar.files " "--automaton = / home / ryan / stuff / .felix / cache / media / ryan / stuff / felix / build / release / share / lib / grammar / grammar.files / syntax.automaton" "- impor = plat / flx.flxh "" std "" /home/ryan/golf/itri/sl.flx "gagal Kesalahan 1 di flx: [strerror_r] Gagal menemukan teks untuk kesalahan nomor 1

Masalahnya ada di sini:

let v = chan.read in ntri += v.value;

letmengharapkan ekspresi untuk mengikutinya, tapi aku malah memberikan pernyataan. Jadi kompiler itu sedikit ketakutan.

Info lebih lanjut di https://groups.google.com/forum/m/#!topic/felix-language/J3Hs4j6E0gM .

JavaScript

while (true === true){
console.log(0);
}

Ini mengirimkannya ke loop tak terbatas. Saya menggunakan kompiler Codecademy JS dan itu crash browser saya.

Javascript

function crash(){
  window.location.hash=Math.random(),onhashchange=function(){crash()}
}

Yang satu ini membuat browser web mogok dengan sangat efektif. GUNAKAN RISIKO ANDA SENDIRI !!!

Hassium

File1.has:

use "File2.has";

File2.has:

use "File1.has";

Ini menyebabkan Hassium memuat dan mulai mengkompilasi File2.has, yang memerintahkannya untuk memuat File1.has, yang menyebabkannya untuk memuat File2.has, dan seterusnya.

LOLCODE 1.2, LOLCODE Penerjemah / Kompiler Umum (lci)

Saya tahu ini bukan kode-golf tetapi sangat singkat.

OBTW

Ini menyebabkan Sinyal 11:

Segmentation fault (core dumped)

Mengapa? HAI1.2menunjukkan awal program, dan OBTWmemulai komentar multiline. Tetapi kompiler mengharapkan a KTHXBYEuntuk menutup HAI, dan TLDRuntuk menutup komentar multiline.

Perhatikan bahwa ini masih akan berfungsi untuk menyebabkan segfault dengan selain dari TLDRsetelah OBTW.

(Menurut standar wikipedia , LOLCODE hanyalah sebuah Weirdlang, bukan benar-benar esoterik.)
Anda dapat mengambil penerjemah dari git / justinmeza / lci .