How to make a C++ EXE larger (artificially)

Question

I want to make a dummy Win32 EXE file that is much larger than it should be. So by default a boiler plate Win32 EXE file is 80 KB. I want a 5 MB one for testing some other utilities.

The first idea is to add a resource, but as it turns out embedded resources are not the same as 5 MB of code when it comes to memory allocation. I am thinking I can reference a large library and end up with a huge EXE file? If not, perhaps scripting a few thousand similar methods like AddNum1, AddNum2, etc., etc.?

Any simple ideas are very appreciated.

Answer 1

You can create big static arrays of dummy data. That would bump your exe size, would not be real code though.

Answer 2

What about simply defining a large static char array?

char const bigarray[5*1024*1024] = { 1 };

See also my other answer in this thread where I suggest statically linking to big libraries. This surely will pull in real code if you just reference enough code of the libraries.

EDIT: Added a non-zero initialization, as data containing zeros only is treated in an optimized fashion by the compiler/linker.

EDIT: Added reference to my other answer.

EDIT: Added const qualifier, so bigarray will be placed amongst code by many compilers.

Answer 3

char big[5*1024*1024] = {1};

You need to initialize it to something other than 0 or the compiler/linker may optimize it.

Answer 4

Write a program that generates a lot of code.

printf("000000000");
printf("000000001");
// ...
printf("010000000");

Answer 5

Use a big array of constant data, like explicit strings:

char *dummy_data[] = {
    "blajkhsdlmf..(long script-generated random string)..",
    "kjsdfgkhsdfgsdgklj..(etc...)...jldsjglkhsdghlsdhgjkh",
};

Unlike variable data, constant data often falls in the same memory section as the actual code, although this may be compiler- or linker-dependent.

Edit: I tested the following and it works on Linux:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int i, j;

    puts("char *dummy_data[] = {");
    for (i = 0; i < 5000; i++) {
        fputs("    \"", stdout);
        for (j = 0; j < 1000; j++) putchar('a' + rand() % 26);
        puts("\",");
    }
    puts("};");
    return 0;
}

Both this code and its output compile cleanly.

Answer 6

How about just adding binary zeroes to the end of the .exe?

Answer 7

If all else fails, you could still create an assembly language source file where you have an appropriate number of db statements emitting bytes into the code segment, and link the resulting code object to your program as extern "C" { ... }.

You might need to play with the compiler/linker to prevent the linker from optimizing away that dummy "code" object.

Answer 8

I've found that even with optimizations, raw strings are kept as is in the compiled executable file.

So the way to go is :

• go to http://lipsum.org/
• generate a lot of text
• add a cpp in your program
• add a static const string that will have the generated text as value
• compile
• check the size.

If your compiler have a limit of raw string size (?) then just make a paragraph per static string.

The added size should be easy to guess.

Answer 9

You could try creating some sort of recursive template that would generate a lot of different instantiations. This could possibly cause a big increase in code size.

Answer 10

Use #define to define lots of macros which holds string with huge length, and use those macros inside your program in many places.

Answer 11

Fill the EXE file with NOPs in assembler.

Answer 12

I admit, I'm a Linux/UNIX guy. Is it possible to statically link an executable in Windows? You then could reference some heavy libs and blow up your code size as much as you want without writing to much code by yourself.

Another idea I pondered while reading your comment to my first answer is appending zeros to your file. As said, I'm no Windows expert, so this might not work.

Answer 13

If it's the file size you want to increase then append a text file to the end of the exe of the required size.

I used to do this when customers would complain of small exes. They didn't realize that small exes are just as professional as larger exes. In fact in some languages there is a bloat() command to increase the size of exes, usually in BASIC compilers.

EDIT: Found an old link to a piece of code that people use: http://www.purebasic.fr/english/viewtopic.php?f=12&t=38994

An example: http://programmers.stackexchange.com/questions/2051/what-is-the-craziest-stupidest-silliest-thing-a-client-boss-asked-you-to-do/2698#2698

Answer 14

Use Boost and compile the executable with debug information.

Answer 15

Add a 5MB (bmp) image.

Answer 16

You could do this:

REM generate gibberish of the desired size
dd if=/dev/random of=entropy count=5000k bs=1
REM copy the entropy to the end of the file
copy /b someapp.exe + entropy somefatapp.exe

If it were a batch file, you could even add it as a post compilation step so it happened automatically.

You can generally copy as much information as you want to the end of an exe. All the code / resources are stored as offsets from the beginning of the file, so increasing it's size shouldn't affect it.

(I'm assuming you have dd in Windows. If not, get it).

Answer 17

Write a code generator that generates arbitrary random functions. The only trick then is making sure that it doesn't get optimized out and with separate compilation that shouldn't be hard.

Answer 18

After you do all the methods listed here, compile with the debug flag and with the highest optimization flag (gcc -g -O3).

Answer 19

Statically link wxWidgets to your application. It will instantly become 5 MB large.

Answer 20

Add lots of resources