Напишіть ідеально юридичний код на гідній мові на ваш вибір, складання якої або руйнує компілятор, або надсилає його у нескінченний цикл (нескінченний час компіляції).

Обмеження:

• Використовуйте стандартну мову, яка використовується в реальному світі.
• Використовуйте стандартний, добре розроблений компілятор (жодних відповідей на кшталт "Я написав свій компілятор C, який випадає на все").
• Код повинен бути легальним мовою (тому, швидше за все, вам доведеться використовувати компілятор або мовну помилку).
• Надайте версію компілятора та використовувані параметри, щоб інші могли її повторити.
• Поясніть, чому компілятор вийшов з ладу, якщо це можливо.

Приємно :)

Я впевнений, що це вже виправлено, але раніше було так, що ви можете збити компілятор Java (або, збій Eclipse), написавши

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

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

Насправді, згідно з цією сторінкою, компілятор просто зависне, а не вийде з ладу. Все-таки я подумав, що це досить весело.

Моє улюблене рішення для 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

Для GHC 6.12.1 ghci Bad.hsі ghc Bad.hsпетлю нескінченно. GHC 7.4.1 петлі нескінченно, коли ghc -O2 Bad.hsвиконується.

Пояснення: omega визначається за допомогою нескінченної рекурсії (єдиний спосіб, коли він може населяти будь-який тип). Інлайнер компілятора розглядає xxяк просту, нерекурсивну функцію, тому намагається вкласти її у визначення omega. Це призводить до (\x@(C x') -> x' x) (C xx). Побачивши відповідність шаблону на конструкторі, компілятор намагається зменшити його, отримуючи xx (C xx)знову і циклічно. Трюк у тому, що xxнасправді є рекурсивним, але рекурсія прихована всередині типу даних.

Примітка. Під час написання головоломки я забув, що залишив GHC працювати у нескінченному циклі. Це зайняло мою пам'ять, розбило Firefox, і я ледве встиг його вбити без жорсткого скидання.

Це легко в будь -якій мові, що залежно від типу . Перевірка загальних типів, що залежать від типу, не можна визначити, оскільки вона може вимагати довільно складних обчислень (завершення Тьюрінга). Ви можете просто кодувати у залежному типі занадто велике значення. Тоді перевірка типу використовує всю наявну пам’ять та аварійне завершення роботи. Наприклад, у Coq ReyCharles наводить прикладCompute 70000. , який змушує перевіряючого типу побудувати гігантську цифру Peano та зазнати краху.

У більш поширених мовах, які підтримують якесь розширення макросу або метапрограмування, ви можете зробити щось подібне. Наприклад, ви можете використовувати всю наявну пам'ять на 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 }

Мова програмування D дозволяє виконувати функцію часу компіляції . Це може бути використано для обчислення чогось під час компіляції, який занадто великий, щоб вміститись у пам'яті. Щось подібного можна досягти за допомогою метапрограмування шаблонів C ++.

У XML (не компільована мова програмування, але процесор XML аналогічний компілятору), розширювані об'єкти можуть змусити процесор втратити пам'ять:

<?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>

Це називається атакою мільярдів сміху .

C #

Знайдено це у запитанні про 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)))))));
    }
}

У підсумку компілятор вийде з ладу.

Проблема, схоже, пов'язана з висновком типу та / або генерацією лямбда в поєднанні з вирішенням перевантаження.

VBA

як щодо того, якщо ви можете зламати IDE, ввівши код?

у будь-якому додатку Microsoft Office спробуйте це:

ALT+, F11щоб потрапити до вікна VBA, а потім спробуйте наступний код

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

і ось:

Ви можете просто ввести redim preserve v(,1 to 5)в безпосереднє вікно, і воно натисне ENTER!

Perl (15)

BEGIN{1while 1}

Це створює нескінченний цикл під час компіляції :

Блок коду BEGIN виконується якнайшвидше, тобто в момент, коли він повністю визначений, ще до того, як буде проаналізовано решта містить файл (або рядок).

(від perlmod )

І тому Perl не в змозі завершити розбір коду. Це не припиняється:

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

J

У цьому сегменті є інтерпретатор J (принаймні в Linux):

15!:1[3#2

Він намагається прочитати з адреси пам'яті 2. Цікаво, що якщо ви спробуєте це з 0 або 1, ви отримаєте domain error.

TeX

\def\x{\x}\x

TeX - мова макророзширення. Тут ми визначаємо розширення макросу , \xщоб бути \xзнову, а потім ми додамо потім закликання \x. TeX застряє нескінченно заміни \xз \x.

Схема

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

Мій компілятор, Chicken, допустив помилку, намагаючись розширити макроси під час компіляції для "виконання часу" або чогось іншого. Тож вона заплатила за розширення цієї. Я читав R5RS. Ніхто не сказав, що макроси потрібно було розгортати під час компіляції.

По суті, те, що відбувається, макрос розширюється до вираження нескінченного розміру, постійно збільшуючись удвічі за розмірами. Ну, щоб бути технічним, подвоюючи кожне інше розширення. Доля компілятора запечатана. Принаймні на моїй системі, Курячі ковпачки на 2 Гб, довго стоять, намагаючись збирати сміття, потім виходять з ладу після відмови сміттєзбірника. Це займе певний час, хоча через всі обчислювально дорогі гігієнічні магії, що трапляються.

Переключення між виразами форми

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

і

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

Здається, дуже-дуже різко збільшує швидкість споживання пам'яті порівняно з:

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

Я підозрюю, що курка - це досить витривалий компілятор, який має деякі способи уникнути глибокого аналізу синтаксичних виразів, коли він може піти з цього, але моє остаточне рішення змушує відповідник шаблону дійсно зануритися.

Звичайний Лисп

Макроси спрощують:

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

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

Компіляція compile-meвикликів loop-forever, яка вичерпує купі пам'яті під час її розширення та вибиває компілятор. Якщо ви просто хочете змусити компілятор зависати нескінченно, то це визначення loop-foreverбуде робити це:

(defmacro loop-forever ()
  (loop))

Це повинно працювати, використовуючи будь-яку реалізацію CL, якщо тільки ваш не дуже розумний і не може виявити прості нескінченні петлі, але я серйозно сумніваюся, що це зробити. Звичайно, повний захист від цього неможливий.

PHP 5.3.1 (інтерпретатор Segfaults) ( помилка 50261 , зафіксована в 5.3.3)

   клас тестовий клас
   {
       функція testClass ()
       {
           echo 'Вихідний рядок!';
       }
   }

   клас testClass2 розширює testClass
   {
       функція __construct ()
       {
           call_user_func (масив ('батьків', '__construct'));
       }
   }

   новий testClass2;

Це було певною проблемою, тому що наведений вище код був поширеним у багатьох кодах, з якими я працював, що зробило це досить поширеним питанням для нас.

(Якщо я пам'ятаю правильно, в один момент це був єдиний спосіб викликати батьківські конструктори в PHP.)

D

(DMD32 D Compiler v2.067.1, збірка Windows)

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

Зауважте, що це відправить компілятор у нескінченний цикл і розбить його.

Помилка: немає пам'яті

Механічний равлик припускав, що функції програмування часу компіляції в D можна використовувати для цієї мети, але рішення, можливо, простіше, ніж той тип прийомів, який він мав на увазі.

Для тих, хто не знайомий з "string mixins", це досить проста макро-функція. Коли компілятор стикається mixin("asdf"), він замінює його вмістом рядка asdfі намагається скомпілювати його ще раз.

Розчин вище буде розширено так:

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

Тому, якщо компілятор не спробує виявити цей випадок розширення на той самий, він введе нескінченний цикл розширення.

Perl

Це визначає перевантаження оператора під час компіляції та запускає код під час компіляції, що додає екземпляри класу разом.

(до речі, зазвичай нескінченна рекурсія з'їсть усю пам'ять, але при перевантаженні вона просто виходить з ладу)

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;
}

Вихід:

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

Simplex v.0.5 , 2 байти

Шкода, що це не гольф з кодом :

2Q

Дозволь пояснити. З документів:

[ Q] Додає вихідний код програми до зовнішньої програми з самого початку (виключаючи символи!!, Якщо поточний байт не дорівнює нулю) Якщо байт 2, дублює також поточну команду.

Тому:

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

Зовнішня програма - це акуратна маленька особливість у Simplex: вона оцінюється в кінці програми. Отже, якщо ми будемо вести облік ...:

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

Врешті-решт пам’ять закінчиться, і світ закінчиться.

Кланг ++

Я щойно натрапив на цю веселу помилку.

#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;
}

Мета - перевести Brainfuck на C, використовуючи мета-програмування шаблонів, щоб виконати більшу частину роботи. Цей код працює для менших програм Brainfuck, таких як Hello World, але коли я намагався запустити його з 99 пляшок ...

$ 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:

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

Він успішно компілюється в GCC (приблизно через 2 хвилини), але посилання на нього спричиняє ще одну проблему ...

/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

На жаль

Маленький розмов (скрипковий діалект, версія 4.x)

Дуже просто, просто оцініть це або прийміть метод із цим буквальним словом

1.0e99999999999999999999

Він спробує оцінити потужність 10 в арифметиці великого цілого числа, лише для правильного округлення inf Tsss;)

Редагувати: скільки 9 потрібно?

Оскільки 2 ^ 10 дорівнює 1024, приблизно 10 ^ 3, ми можемо приблизно наближати 10 ^ n на 2 ^ (10 * n / 3). Це означає, що 10 ^ n вимагає, щоб 10 * n / 3 біти були представлені у двійкових. Ми хотіли б, щоб 10 ^ n не були репрезентативними.

Припускаючи 32-бітові вказівники для об'єктної пам'яті, ми знаємо, що ми не можемо адресувати більше 2 ^ 32 байт, тобто 2 ^ 35 біт. Тож повернемо задачу: 2 ^ 35 - це приблизно 32 * 2 ^ 30, 32 * 10 ^ 9. Для цього потрібно близько 11 десяткових цифр, тому з одинадцятьма 9 ми впевнені, що вони створюють помилку на 32-бітному Squeak. У 64 бітах це було б двадцять один 9.

Ми також можемо вичерпати пам’ять з меншими 9-ти, весь адресований простір не обов'язково доступний, але це смертельно повільно тестувати, Squeak VM не оптимізований для такої гігантської арифметики на відміну від GMP.

Це мій оригінальний і стислий спосіб зірвати GolfScript:

{1.}do

Для цього потрібно створити вічний цикл, який продовжує натискати 1 на стек, поки не вичерпається пам'ять.

В C / C ++ я вважаю, що цей оригінальний фрагмент коду призведе до краху компілятора:

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

Це призведе до того, що компілятор застряг удвічі збільшив об'єм і перетворив їх на b, і навпаки, тож у компілятора досить скоро не вистачило б пам'яті та вийшло з ладу.

Ще один варіант - для пакетної роботи в Windows, якщо підраховується повністю заморожування комп'ютера, а не лише сам пакетний сценарій. Ви повинні ввести наступне:

:a
start %0
goto a

Це потрапляє у нескінченний цикл виготовлення копій, які роблять копії себе тощо. Це, швидше за все, збить ваш комп'ютер, якби ви запустили цей маленький код.

Останнє - бомба VBS. Це ще одна бомба, як і остання, але вона натомість відкриває нескінченну кількість діалогових вікон.

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

Це постійно створює копію себе і відкриває вікно повідомлень у нескінченному циклі, що також роблять клони. Запуск цих двох останніх програм не рекомендується, оскільки вони можуть заморозити ваш комп'ютер і призвести до того, що вам доведеться важко завантажувати комп'ютер.

Зауважте, що всі ці програми я придумав сам.

Лист звичайний, 8 байт

Коротше, ніж інші відповіді звичайного Лиса :-)

#.(loop)

Цикл під час читання форми.

Загальний стандарт Lisp не згадує про портативний спосіб його збою, тому, мабуть, нам потрібно мати спосіб, визначений реалізацією. Ще 8 байт:

#.(quit) ; ccl

... або,

#.(exit) ; sbcl

Коли ви телефонуєте (compile-file "crash.lisp"), оточення таємниче "розбиваються".

Жартуючи на частини, я все ще намагаюся знайти спосіб справді розбити навколишнє середовище (і незабаром), але це справді важко. Все, що я отримую, це приємна взаємодія з налагоджувачем.

x86 асм

"nasm -v" повертає "NASM версії 2.11.08, складеної 21 лютого 2015 року" (я запускаю її під win7)

Наразі асемблер працює 1:12:27 на i7, повністю насичуючи одне з ядер. Вихідний файл сидить на рівні 0 байт, споживання пам’яті було стабільним на рівні 1 004 Кб - здається, сміливо сказати, що я побив насма, а не просто дав йому справді дуже дійсне завдання. :)

Ключ до хитрості - це значення повторення в макросі - 0xFFFFFFFF. Хоча я недостатньо знайомий із внутрішніми засобами Nasm, щоб знати, чому саме це задихається. Я очікував отримати ~ 16 Гб годину тому.

%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: Щойно перевірив диспетчер завдань, Nasm працює вже 7:40:41, а тепер обсяг пам'яті становить до 1,016K

Gnu асемблер, генеруючи величезні вихідні файли

Цей макрос намагається заповнити вихідний файл сміттям (як правило, нульовими байтами), поки не буде досягнуто межі 4 Гб, додає int, щоб пройти цю межу, і рекурсивно закликає себе продовжувати заповнювати вихід 4 шматками сміття. Це наповнить ваш жорсткий диск, поки він не заповниться, і тоді асемблер, швидше за все, вийде з ладу.

.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)

Зауважте, що нескінченну рекурсію використовувати не можна, оскільки асемблер зафіксує цей особливий випадок і перестане розширювати макрос.

Компіляцію можна виконати з as -o crash.out crash.sбільшості дистрибутивів Linux.

Лист звичайний, 29 байт

Реалізація: закриття CL

ПОПЕРЕДЖЕННЯ. Будьте обережні, виконуючи цей код, він може вбивати процеси, які ви не хочете!

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

Це запускає команду shell pkill clна час компіляції, що вбиває процес Lisp, виконуючи компіляцію. Технічно не збій, але це має той же ефект.

Приклад використання:

$ 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
$ 

Фелікс

Це більше не працює, але в один момент цей код:

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;

Це призведе до великої помилки:

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

СИСТЕМА ЗНАТИ bind_expression 'підвищено Not_found [BUG] Компіляція 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 / реліз / 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 / gramatika.files / syntax.automaton" "--import = plat / flx.flxh "" std "" /home/ryan/golf/itri/sl.flx "не вдалося Помилка 1 у flx: [strerror_r] Не вдалося знайти текст для помилки номер 1

Проблема була тут:

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

letочікував, що вираз буде слідувати цьому, але я поставив замість цього. Тож компілятор вибухнув тату.

Більше інформації на https://groups.google.com/forum/m/#!topic/felix-language/J3Hs4j6E0gM .

JavaScript

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

Це посилає його в нескінченну петлю. Я використав компілятор Codecademy JS, і він розбив мій браузер.

Javascript

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

Цей веб-браузер серйозно діє. ВИКОРИСТОВУЙТЕ НА ВЛАСНОМУ РИЗИКІ !!!

Hassium

File1.has:

use "File2.has";

File2.has:

use "File1.has";

Це змушує Hassium завантажуватися та починати компілювати File2.has, що повідомляє йому завантажувати File1.has, що змушує його завантажувати File2.has тощо.

LOLCODE 1.2, загальний перекладач / компілятор LOLCODE (lci)

Я знаю, що це не кодовий гольф, але все одно дуже короткий.

OBTW

Це викликає сигнал 11:

Segmentation fault (core dumped)

Чому? HAI1.2позначає початок програми та OBTWініціює багаторядковий коментар. Але компілятор розраховує KTHXBYEна те, що "закрити" HAI, а "" - TLDRзакрити багаторядковий коментар.

Зауважте, що це все ще працюватиме, щоб викликати segfault з будь-яким іншим, ніж TLDRпісля OBTW.

(За стандартами вікіпедії , LOLCODE - це просто Weirdlang, а не насправді езотерика.)
Ви можете схопити інтерпретатора від git / justinmeza / lci .