前書き

zip爆弾、XML爆弾などはおなじみでしょう。簡単に言えば、それらは（比較的）ナイーブソフトウェアによって解釈されたときに膨大な出力を生成する小さなファイルです。ここでの課題は、同じ方法でコンパイラを悪用することです。

チャレンジ

512バイト以下を占有し、可能な限りスペースを占有するファイルにコンパイルするソースコードを記述します。最大の出力ファイルが勝ちます！

ルール

わかりましたので、いくつかの重要な説明、定義、制限があります。

• コンパイルの出力は、ELFファイル、Windows Portable Executable（.exe）、またはJVMまたは.NetのCLRの仮想バイトコードである必要があります（要求された場合、他のタイプの仮想バイトコードでも大丈夫です）。更新：Pythonの.pyc / .pyo出力もカウントされます。
• 選択した言語をこれらの形式のいずれかに直接コンパイルできない場合は、コンパイルとそれに続くコンパイルも許可されます（更新：同じ言語を複数回使用しない限り、複数回トランスコンパイルできます）。
• ソースコードは複数のファイル、さらにはリソースファイルで構成できますが、これらすべてのファイルの合計サイズは512バイトを超えてはなりません。
• ソースファイルと選択言語の標準ライブラリ以外の入力は使用できません。静的リンク標準ライブラリは、サポートされていれば問題ありません。具体的には、サードパーティのライブラリやOSライブラリはありません。
• コマンドまたは一連のコマンドを使用してコンパイルを呼び出すことが可能でなければなりません。コンパイル時に特定のフラグが必要な場合、これらはバイト制限にカウントされます（たとえば、コンパイル行がのgcc bomb.c -o bomb -O3 -lm場合、-O3 -lmパート（7バイト）がカウントされます（最初の先行スペースはカウントされないことに注意してください）。
• プリプロセッサは、言語の標準コンパイルオプションである場合にのみ許可されます。
• 環境はあなた次第ですが、これを検証可能にするために、最新の（つまり、利用可能な）コンパイラーのバージョンとオペレーティングシステムに固執してください（そして明らかに使用しているものを指定してください）。
• エラーなしでコンパイルする必要があり（警告は問題ありません）、コンパイラのクラッシュは何もカウントしません。
• あなたのプログラムが実際に行うことは無関係ですが、悪意のあることはできません。開始する必要さえありません。

例1

Cプログラム

main(){return 1;}

Apple LLVM version 7.0.2 (clang-700.1.81)OS X 10.11（64ビット）でコンパイル：

clang bomb.c -o bomb -pg

9228バイトのファイルを作成します。ソースの合計サイズは17 + 3（の場合-pg）= 20バイトで、サイズ制限内に容易に収まります。

例2

Brainfuckプログラム：

++++++[->++++++++++++<]>.----[--<+++>]<-.+++++++..+++.[--->+<]>-----.--
-[-<+++>]<.---[--->++++<]>-.+++.------.--------.-[---<+>]<.[--->+<]>-.

awibを使用してcに変換：

./awib < bomb.bf > bomb.c

次にApple LLVM version 7.0.2 (clang-700.1.81)、OS X 10.11（64ビット）でコンパイルします。

clang bomb.c

8464バイトのファイルを作成します。ここでの合計入力は143バイトです（@lang_cソースファイルに追加する必要がないawibのデフォルトであるため、どちらのコマンドにも特別なフラグはありません）。

また、この場合、一時的なbomb.cファイルは802バイトですが、これはソースサイズにも出力サイズにもカウントされないことに注意してください。

最終ノート

4GB以上の出力が達成された場合（おそらく誰かが完全なプリプロセッサを探している場合）、少なくともそのサイズのファイルを生成する最小のソースを競います（大きすぎる提出物をテストすることは実際的ではありません） 。

C、（14 + 15）= 29バイトのソース、17,179,875,837（16 GB）バイトの実行可能ファイル

6バイトオフの@viraptorに感謝します。

@hvdに2バイトのオフと実行可能サイズx4のおかげです。

これは、main関数を大きな配列として定義し、その最初の要素を初期化します。これにより、GCCは配列全体を結果の実行可能ファイルに保存します。

この配列は2GBより大きいため、-mcmodel=mediumGCCにフラグを提供する必要があります。ルールに従って、余分な15バイトがスコアに含まれます。

main[-1u]={1};

実行時にこのコードが何か良いことをすると期待しないでください。

コンパイル：

gcc -mcmodel=medium cbomb.c -o cbomb

@hvdの提案をテストするのに時間がかかり、それを処理するのに十分なジュースのあるマシンを見つけるのに時間がかかりました。最終的に、10GB RAM、12GBスワップ、および/ tmpが大きなローカルパーティションに設定された古い非実稼働RedHat 5.6 VMを見つけました。GCCバージョンは4.1.2です。合計コンパイル時間は約27分です。

CPUとRAMの負荷のため、リモートで生産関連のマシンでこのコンパイルを行わないことをお勧めします。

C＃、コンパイルに約1分、28MBの出力バイナリ：

class X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}

Yを追加すると、サイズが指数関数的に増加します。

@OdomontoisのリクエストによるPharapの説明：

この答えは、再帰を作成するために継承と型パラメーターを乱用しています。何が起こっているのかを理解するには、最初に問題を単純化するほうが簡単です。考えてみましょう。これは、内部クラスを持つclass X<A> { class Y : X<Y> { Y y; } }汎用クラスを生成します。継承、したがってまた、内部クラス有し、その後で、。これには内部クラスもあり、その内部クラスには内部クラスなどがあります。つまり、スコープ解決（）を無限に使用でき、使用するたびに、コンパイラは別のレベルの継承と型パラメーター化を推測する必要があります。X<A>YX<A>.YX<Y>X<A>.YYX<A>.Y.YYYY.

追加の型パラメーターを追加することにより、コンパイラーが各段階で行う作業がさらに増加し​​ます。

以下の例を考えてみましょう。
ではclass X<A> { class Y : X<Y> { Y y;} }typeのparam Aの型がありますX<A>.Y。
ではclass X<A> { class Y : X<Y> { Y.Y y;} }typeのparam Aの型がありますX<X<A>.Y>.Y。
ではclass X<A> { class Y : X<Y> { Y.Y.Y y;} }typeのparam Aの型がありますX<X<X<A>.Y>.Y>.Y。
ではclass X<A,B> { class Y : X<Y,Y> { Y y;} }タイプparamがAあるX<A,B>.YとBされますX<A,B>.Y。
ではclass X<A> { class Y : X<Y> { Y.Y y;} }タイプparamがAあるX<X<A,B>.Y, X<A,B>.Y>.YとBされますX<X<A,B>.Y, X<A,B>.Y>.Y。
ではclass X<A> { class Y : X<Y> { Y.Y.Y y;} }タイプparamがAあるX<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.YとBされますX<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y。

このパターンに続き、1しか想像できる¹コンパイラが何を推測するために行う必要があります作業AしEているY.Y.Y.Y.Y.Y.Y.Y.Y定義でclass X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}。

¹あなたはそれを理解することができましたが、あなたは多くの忍耐を必要とするでしょう、そしてインテリセンスはここであなたを助けません。

Python 3、13バイトのソース、9,057,900,463バイト（8.5GiB）.pycファイル

(1<<19**8,)*2

編集：4GiBを超える出力サイズは重要ではないとルールに気づいた後、コードを上記のバージョンに変更しました。前のコード、さらに重要な説明は以下にあります。

Python 3、16バイトソース、32 TBを超える.pycファイル（十分なメモリ、ディスクスペース、忍耐力がある場合）

(1<<19**8,)*4**7

説明：Python 3は定数畳み込みを行い、べき乗を使用して大きな数を高速に取得します。.pycファイルで使用される形式は、4バイトを使用して整数表現の長さを格納しますが、実際には制限はより似ているよう2**31に見えるため、指数を使用して1つの大きな数を生成すると、制限は2GBを生成するようです。 8バイトのソースからのpycファイル。（19**8は少し恥ずかしがり屋な8*2**31ので1<<19**8、2GB未満のバイナリ表現があります。8倍するのは、ビットではなくバイトが必要なためです）

ただし、タプルも不変であり、タプルの乗算も一定に折りたたまれているため、その2GBのBLOBを必要な2**31回数（少なくとも最大で）複製できます。4**732TBに到達するためには、それが私はそれが前の16TBの答えを打つ見つけることができる最初の指数だったという理由だけで選ばれました。

残念ながら、自分のコンピューターにあるメモリでは、乗数2までしかテストできませんでした。(1<<19**8,)*2、8.5GBファイルを生成しました。これが答えが現実的であることを証明することを望みます（つまり、ファイルサイズは2 ** 32 = 4GBに制限されません）。

また、テスト時に得られたファイルサイズが、予想した4GBの代わりに8.5GBだった理由がわかりません。また、ファイルが十分に大きいので、現時点ではそれをいじる気は​​ありません。

4GB以上の出力が達成された場合（おそらく誰かが完全なプリプロセッサを探している場合）、少なくともそのサイズのファイルを生成する最小のソースを競います（大きすぎる提出物をテストすることは実際的ではありません） 。

「テンプレートHaskell」を使用すると、Haskellを使用してコンパイル時にHaskellコードを生成できるため、完全なプリプロセッサです。

これは、任意の数値式によってパラメーター化された私の試みFOOです。

import Language.Haskell.TH;main=print $(ListE .replicate FOO<$>[|0|])

魔法は、「スプライス」内のコード$(...)です。これはコンパイル時に実行され、スプライスの代わりにプログラムのASTに移植されるHaskell ASTを生成します。

この場合、リテラルを表す単純なASTを作成し、0今回複製しFOOてリストを作成ListEし、Language.Haskell.THモジュールからこのASTのリストをリテラルを表す1つの大きなASTに変換し[0, 0, 0, 0, 0, ...]ます。

得られたプログラムは、と等価であるmain = print [0, 0, 0, ...]とFOOの繰り返し0。

ELFにコンパイルするには：

$ ghc -XTemplateHaskell big.hs
[1 of 1] Compiling Main             ( big.hs, big.o )
Linking big ...
$ file big
big: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /nix/store/mibabdfiaznqaxqiy4bqhj3m9gaj45km-glibc-2.21/lib/ld-linux.so.2, for GNU/Linux 2.6.32, not stripped

これは、83バイト（Haskellコードの場合は66、-XTemplateHaskell引数の場合は17 ）に加えて、FOO。

コンパイラー引数を避けて、でコンパイルすることもできますがghc、{-# LANGUAGE TemplateHaskell#-}先頭に配置する必要があります。これにより、コードが最大97バイト増えます。

の式の例FOOと、結果のバイナリのサイズを次に示します。

FOO         FOO size    Total size    Binary size
-------------------------------------------------
(2^10)      6B          89B           1.1MB
(2^15)      6B          89B           3.6MB
(2^17)      6B          89B           12MB
(2^18)      6B          89B           23MB
(2^19)      6B          89B           44MB

でRAMコンパイルを使い果たしました(2^20)。

のrepeat代わりにを使用して無限リストを作成することもできますがreplicate FOO、これによりコンパイラが停止するのを防ぎます;）

C ++、250 + 26 = 276バイト

template<int A,int B>struct a{static const int n;};
template<int A,int B>const int a<A,B>::n=a<A-1,a<A,B-1>::n>::n;
template<int A>struct a<A,0>{static const int n=a<A-1,1>::n;};
template<int B>struct a<0,B>{static const int n=B+1;};
int h=a<4,2>::n;

これは、テンプレートに実装されたアッカーマン関数です。h=a<4,2>::n;私の小さな（6GB）マシンではコンパイルできませんがh=a<3,14>、26Mの出力ファイルを管理しました。プラットフォームの制限に達するように定数を調整できます-ガイダンスについては、リンクされているウィキペディアの記事を参照してください。

必要と-gGCCへのフラグ（それが実際にどのスペースを消費し、すべてのデバッグシンボルだから）、およびデフォルトより大きくテンプレートの深さを。私のコンパイル行は最終的に

g++ -ftemplate-depth=999999 -g -c -o 69189.o 69189.cpp

プラットフォーム情報

g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2
Linux 3.13.0-46-generic #79-Ubuntu SMP x86_64 GNU/Linux

ASM、61バイト（29バイトのソース、32バイトのフラグ）、4,294,975,320バイトの実行可能ファイル

.globl main
main:
.zero 1<<32

コンパイルする gcc the_file.s -mcmodel=large -Wl,-fuse-ld=gold

2005年からの私のCの答えは次のとおりです。

struct indblock{
   uint32_t blocks[4096];
};

struct dindblock {
    struct indblock blocks[4096];
};

struct tindblock {
    struct dindblock blocks[4096];
};

struct inode {
    char data[52]; /* not bothering to retype the details */
    struct indblock ind;
    struct dindblock dint;
    struct tindblock tind;
};

struct inode bbtinode;

int main(){}

従来のCプリプロセッサ：214バイトの入力、5MBの出力

私の実世界のプリプロセッサに触発されて、ここで失敗します。

#define A B+B+B+B+B+B+B+B+B+B
#define B C+C+C+C+C+C+C+C+C+C
#define C D+D+D+D+D+D+D+D+D+D
#define D E+E+E+E+E+E+E+E+E+E
#define E F+F+F+F+F+F+F+F+F+F
#define F x+x+x+x+x+x+x+x+x+x

int main(void) { int x, y = A; }

実験では、#definesの各レベルが（予想どおり）出力を約10倍大きくすることが示されています。しかし、この例ではコンパイルに1時間以上かかったため、「G」に進むことはありませんでした。

Java、450 + 22 = 472バイトのソース、最大1 GBのクラスファイル

B.java（ゴルフバージョン、コンパイル中の警告）

import javax.annotation.processing.*;@SupportedAnnotationTypes("java.lang.Override")public class B extends AbstractProcessor{@Override public boolean process(java.util.Set a,RoundEnvironment r){if(a.size()>0){try(java.io.Writer w=processingEnv.getFiler().createSourceFile("C").openWriter()){w.write("class C{int ");for(int i=0;i<16380;++i){for(int j=0;j<65500;++j){w.write("i");}w.write(i+";int ");}w.write("i;}");}catch(Exception e){}}return true;}}

B.java（非ゴルフバージョン）

import java.io.Writer;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;

@SupportedAnnotationTypes("java.lang.Override")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class B extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (annotations.size() > 0) {
            try (Writer writer = processingEnv.getFiler().createSourceFile("C").openWriter()) {
                writer.write("class C{int ");
                for (int i = 0; i < 16380; ++i) {
                    for (int j = 0; j < 65500; ++j) {
                        writer.write("i");
                    }
                    writer.write(i + ";int ");
                }
                writer.write("i;}");
            } catch (Exception e) {
            }
        }
        return true;
    }
}

編集

javac B.java
javac -J-Xmx16G -processor B B.java

説明

この爆弾は注釈プロセッサを使用します。2回のコンパイルパスが必要です。最初のパスでは、プロセッサクラスが構築されますB。2回目のパスで、プロセッサは新しいソースファイルを作成し、バイトサイズC.javaのにコンパイルします。C.class1,073,141,162

大きなクラスファイルを作成しようとすると、いくつかの制限があります。

• 約64kより長い識別子を作成すると、次の結果になりますerror: UTF8 representation for string "iiiiiiiiiiiiiiiiiiii..." is too long for the constant pool。
• 約64kを超える変数/関数を作成すると、次の結果になります。 error: too many constants
• 関数のコードサイズには約64kの制限もあります。
• Javaコンパイラには、.classファイルに対して約1GBの一般的な制限（バグ？）があるようです。上記のコードでを増やす16380と16390、コンパイラは戻りません。
• .javaファイルには約1GBの制限もあります。増加16380に16400上記のコードの結果に：An exception has occurred in the compiler (1.8.0_66). Please file a bug ...が続きますjava.lang.IllegalArgumentException。

C、26バイトのソース、2,139,103,367バイトの出力、有効なプログラム

const main[255<<21]={195};

使用してコンパイル：gcc cbomb.c -o cbomb（gccバージョン4.6.3、Ubuntu 12.04、約77秒）

コマンドラインオプションを使用せずに有効なプログラムを作成できる大きさを確認しようと思いました。この答えからアイデアを得ました：Digital Traumaによるhttps://codegolf.stackexchange.com/a/69193/44946 これがコンパイルされる理由についてのコメントを参照してください。

仕組み：constは、セグメント内のページから書き込みフラグを削除するため、mainを実行できます。これ195は、戻り用のIntelマシンコードです。また、Intelアーキテクチャはリトルエンディアンであるため、これが最初のバイトです。プログラムは、eaxレジスタに設定された起動コード（おそらく0）で終了します。

リンカはオフセットに32ビットの符号付き値を使用しているため、わずか2ギガです。コンパイラ/リンカーが動作するためにいくらかのスペースを必要とするため、2ギガよりも8メガバイト小さく、これはリンカエラーなしで取得できる最大のものです-ymmv。

Boo、71バイト。コンパイル時間：9分。134,222,236バイトの実行可能ファイル

macro R(e as int):
 for i in range(2**e):yield R.Body
x = 0
R 25:++x

マクロR（Repeat用）を使用して、コンパイラーに任意の回数、インクリメントステートメントを乗算させます。特別なコンパイラフラグは必要ありません。ファイルを名前を付けて保存しbomb.boo、コンパイラを呼び出しbooc bomb.booてビルドします。

Kotlin、ソース90バイト、177416バイト（173 KB）コンパイル済みJVMバイナリ

inline fun a(x:(Int)->Any){x(0);x(1)}
fun b()=a{a{a{a{a{a{a{a{a{a{a{println(it)}}}}}}}}}}}

技術的には、式をさらにネストすることでこれをさらに長くすることができます。ただし、StackOverflow再帰を増やすと、コンパイラはエラーでクラッシュします。

C ++、214バイト（特別なコンパイルオプションは不要）

#define Z struct X
#define T template<int N
T,int M=N>Z;struct Y{static int f(){return 0;}};T>Z<N,0>:Y{};T>Z<0,N>:Y{};T,int M>Z{static int f(){static int x[99999]={X<N-1,M>::f()+X<N,M-1>::f()};}};int x=X<80>::f();

これは、かなり単純な2次元テンプレート再帰です（再帰の深さは、放出されるテンプレートの合計の平方根になるため、プラットフォームの制限を超えません）。それぞれに少量の静的データがあります。

生成されたオブジェクトファイルg++ 4.9.3 x86_64-pc-cygwinは2567355421バイト（2.4GiB）です。

初期値を80より大きくすると、cygwin gccアセンブラーが壊れます（セグメントが多すぎます）。

また、ソースコードを変更せずにサイズを大きくするために99999置き換えることができ9<<19ます...

Scala-70バイトのソース、22980842バイトの結果（jarの後）

import scala.{specialized => s}
class X[@s A, @s B, @s C, @s D, @s E]

これにより、9 ⁵（約59,000）の特殊なクラスファイルが生成され、約23 MBのjarにパックされます。その数のファイルと十分なメモリを処理できるファイルシステムがあれば、原則として続行できます。

（jarコマンドを含める必要がある場合、82バイトです。）

C、-cinの場合は284バイト+ 2 gcc bomb.c -o bomb.o -c。出力：2 147 484 052バイト

#define a 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
#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
__int128 x[]={f,f,f,f,f,f,f,f};

ブー、これから期待できる以上の方法

macro R(e as int):for i in range(9**e):yield R.Body
x = 0
R 99:++x

Python 3：

9**9**9**9**9

爆弾爆弾