介绍

您可能熟悉zip炸弹，XML炸弹等。简单来说，它们是（相对）小文件，当用纯软件解释时，它们会产生巨大的输出。这里的挑战是以同样的方式滥用编译器。

挑战

编写一些占用512个字节或更少字节的源代码，并将其编译成一个占用最大可能空间的文件。最大的输出文件胜出！

规则

好的，因此有一些重要的说明，定义和限制。

• 编译的输出必须是ELF文件，Windows Portable可执行文件（.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_cawib的默认设置是不需要将其添加到源文件中，并且两个命令中都没有特殊标志）。

还要注意，在这种情况下，临时的bomb.c文件为802字节，但这不会计入源大小或输出大小。

最后说明

如果实现了超过4GB的输出（也许有人找到了一个完整的预处理器），那么竞争将是争夺产生至少该大小文件的最小源（测试提交太大的文件是不切实际的） 。

C，（14 + 15）= 29字节源，17,179,875,837（16 GB）字节可执行

感谢@viraptor关闭了6个字节。

感谢@hvd关闭2个字节，并且可执行文件大小为x4。

这将main函数定义为大数组并初始化其第一个元素。这导致GCC将整个数组存储在生成的可执行文件中。

因为此数组大于2GB，所以我们需要将-mcmodel=medium标志提供给GCC。根据规则，分数中包括了额外的15个字节。

main[-1u]={1};

不要指望此代码在运行时会做任何有益的事情。

编译：

gcc -mcmodel=medium cbomb.c -o cbomb

我花了一些时间来测试@hvd的建议-并找到一台有足够果汁来处理它的机器。最终，我找到了一个旧的非生产型RedHat 5.6 VM，它具有10GB RAM，12GB交换空间和/ tmp设置为大型本地分区。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将成倍增加大小。

Pharap根据@Odomontois的要求进行了解释：

这个答案是滥用继承和类型参数来创建递归。要了解正在发生的事情，首先简化问题会更容易。考虑一下class X<A> { class Y : X<Y> { Y y; } }，它会生成X<A>具有内部类的通用类Y。X<A>.Y继承X<Y>，因此X<A>.Y也有一个内部类Y，然后是X<A>.Y.Y。然后，它也具有一个内部类Y，而该内部类Y具有一个内部类Y等。这意味着您可以.无限使用范围解析（），并且每次使用时，编译器都必须推断出继承和类型参数化的另一个层次。 。

通过添加其他类型参数，可以进一步提高编译器在每个阶段必须执行的工作。

请考虑以下情况：
在class X<A> { class Y : X<Y> { Y y;} }类型param中A具有类型X<A>.Y。
在class X<A> { class Y : X<Y> { Y.Y y;} }类型中，param A的类型为X<X<A>.Y>.Y。
在class X<A> { class Y : X<Y> { Y.Y.Y y;} }类型中，param A的类型为X<X<X<A>.Y>.Y>.Y。
在class X<A,B> { class Y : X<Y,Y> { Y y;} }类型param中，Ais X<A,B>.Y和Bis X<A,B>.Y。
在class X<A> { class Y : X<Y> { Y.Y y;} }类型param中，Ais X<X<A,B>.Y, X<A,B>.Y>.Y和Bis X<X<A,B>.Y, X<A,B>.Y>.Y。
在class X<A> { class Y : X<Y> { Y.Y.Y y;} }类型param中，Ais X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y和Bis X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y。

根据这一模式，人们只能想象¹工作的编译器必须做的推断出什么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;}}。

¹您可以弄清楚，但是您需要很多耐心，而intellisense不会在这里为您提供帮助。

Python 3、13字节源，9,057,900,463字节（8.5GiB）.pyc文件

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

编辑：在我意识到规则说输出大小超过4GiB无关紧要之后，将代码更改为上述版本，并且该代码的代码变得如此短；先前的代码-更重要的是解释-可以在下面找到。

Python 3，16字节源，> 32TB .pyc文件（如果您有足够的内存，磁盘空间和耐心）

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

说明：Python 3会不断折叠，并且使用指数运算可以快速获得大量数字。.pyc文件使用的格式使用4个字节存储整数表示的长度，但实际上限制似乎更像2**31，因此仅使用指数生成一个大数字，限制似乎正在生成2GB。来自8字节源的pyc文件。（19**8有点害羞8*2**31，所以1<<19**8具有2GB以下的二进制表示形式；乘以八是因为我们需要字节而不是位）

但是，元组也是不可变的，并且将元组相乘也是固定折叠的，因此我们可以根据需要将2GB blob复制2**31多次，至少可以复制几次。在4**7去32TB的选择，只是因为这是我能找到击败了以往16TB回答第一个指数。

不幸的是，有了我自己的计算机上的内存，我最多只能测试2的乘数，即。(1<<19**8,)*2，该文件生成了8.5GB的文件，我希望证明答案是现实的（即文件大小不限于2 ** 32 = 4GB）。

另外，我也不知道为什么测试时得到的文件大小是8.5GB，而不是我期望的4GB，而且文件太大，以至于我现在不想在周围乱弹。

如果实现了超过4GB的输出（也许有人找到了一个完整的预处理器），那么竞争将是争夺产生至少该大小文件的最小源（测试提交太大的文件是不切实际的） 。

“模板Haskell”允许使用Haskell在编译时生成Haskell代码，因此它是一个完整的预处理器。

这是我的尝试，通过任意数值表达式进行参数设置FOO：

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

魔术是“接头”中的代码$(...)。这将在编译时执行，以生成Haskell AST，该Haskell AST代替拼接被移植到程序的AST上。

在这种情况下，我们制作一个表示文字的简单AST 0，复制此FOO时间以创建一个列表，然后ListE从Language.Haskell.TH模块中使用将此AST列表转换为一个表示文字的大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

它-XTemplateHaskell的长度为83个字节（Haskell代码为66个字节，自变量为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;

这是在模板中实现的Ackermann函数。我无法h=a<4,2>::n;在小型（6GB）的计算机上进行编译，但是我确实管理h=a<3,14>了26M的输出文件。您可以调整常数以达到平台的极限-请参阅链接的Wikipedia文章以获得指导。

需要-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答案。如果您有16TB RAM（没有），将产生16TB二进制文件。

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 级（如预期的那样）会使输出大约大十倍。但是由于该示例花费了一个多小时的编译时间，所以我再也没有继续进行“ G”操作。

Java，450 + 22 = 472字节源，〜1GB类文件

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。在第二遍过程中，处理器将创建一个新的源文件C.java，并将其编译C.class为1,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是退货的英特尔机器代码。而且由于英特尔架构是低端的，因此这是第一个字节。该程序将以eax寄存器中放置的任何启动代码退出，可能为0。

它仅约2 gig，因为链接器使用32位带符号的偏移量值。它比2 gig小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();

这是一个非常简单的二维模板递归（递归深度与所发出的总模板的平方根成正比，因此不会超出平台限制），每一个中都有少量静态数据。

生成的目标文件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 ^5个（约59,000个）专业类文件，这些文件打包到一个约23 MB的jar中。如果您有一个可以处理那么多文件和足够内存的文件系统，原则上可以继续进行。

（如果必须包含jar命令，则为82个字节。）

C，284字节+ 2 for -cin gcc bomb.c -o bomb.o -c; 输出：2147484052字节

#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

诱惑炸弹