portable - dev c++ software download
Cómo hacer un C++ EXE más grande(artificialmente) (19)
¿Qué hay de simplemente definir una gran matriz de caracteres estáticos?
char const bigarray[5*1024*1024] = { 1 };
Vea también mi otra respuesta en este hilo donde sugiero enlazar estáticamente a grandes bibliotecas. Esto seguramente atraerá código real si solo hace referencia al código suficiente de las bibliotecas.
EDITAR: Se agregó una inicialización distinta de cero, ya que los datos que contienen ceros solo son tratados de manera optimizada por el compilador / enlazador.
EDITAR: Agregado referencia a mi otra respuesta.
EDITAR: Se agregó const calificador, por lo que muchos compiladores colocarán Bigarray entre el código.
Quiero hacer un archivo Win32 EXE ficticio que sea mucho más grande de lo que debería ser. Entonces, por defecto, un archivo Win32 EXE de placa de caldera es de 80 KB. Quiero un 5 MB uno para probar algunas otras utilidades.
La primera idea es agregar un recurso, pero resulta que los recursos incrustados no son lo mismo que 5 MB de código cuando se trata de la asignación de memoria. ¿Estoy pensando que puedo hacer referencia a una gran biblioteca y terminar con un archivo EXE enorme? Si no es así, ¿tal vez scripting unos pocos miles de métodos similares como AddNum1, AddNum2, etc., etc.?
Cualquier idea simple es muy apreciada.
¿Qué tal si solo agregamos ceros binarios al final del archivo .exe?
Admito que soy un chico de Linux / UNIX. ¿Es posible vincular estáticamente un ejecutable en Windows? Luego podría hacer referencia a algunas librerías pesadas y hacer volar el tamaño de su código todo lo que quiera sin tener que escribir demasiado código por su cuenta.
Otra idea que pensé mientras leía su comentario a mi primera respuesta es agregar ceros a su archivo. Como dije, no soy un experto en Windows, así que esto podría no funcionar.
Agregue una imagen de 5MB (bmp).
Descubrí que incluso con optimizaciones, las cadenas en bruto se mantienen tal como están en el archivo ejecutable compilado.
Así que el camino a seguir es:
- ir a http://lipsum.org/
- generar mucho texto
- añade un cpp en tu programa
- agregue una cadena de const estática que tendrá el texto generado como valor
- compilar
- Compruebe el tamaño.
Si su compilador tiene un límite de tamaño de cadena sin formato (?), Simplemente haga un párrafo por cadena estática.
El tamaño añadido debe ser fácil de adivinar.
Después de realizar todos los métodos enumerados aquí, compile con el indicador de depuración y con el indicador de optimización más alto ( gcc -g -O3 ).
Enlace estático wxWidgets a su aplicación. Instantáneamente se convertirá en 5 MB de gran tamaño.
Escribe un generador de código que genere funciones aleatorias arbitrarias. El único truco entonces es asegurarse de que no se optimice y con una compilación separada que no debería ser difícil.
Escribe un programa que genere mucho código.
printf("000000000");
printf("000000001");
// ...
printf("010000000");
Podrías hacer esto:
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
Si se tratara de un archivo por lotes, incluso podría agregarlo como un paso de compilación posterior para que sucediera automáticamente.
En general, puede copiar toda la información que desee al final de un archivo ejecutable. Todos los códigos / recursos se almacenan como compensaciones desde el principio del archivo, por lo que aumentar su tamaño no debería afectarlo.
(Supongo que tienes dd en Windows. Si no, consíguelo).
Puede crear grandes matrices estáticas de datos ficticios. Eso aumentaría tu tamaño exe, aunque no sería un código real.
Puedes intentar crear algún tipo de plantilla recursiva que genere muchas instancias diferentes. Esto podría causar un gran aumento en el tamaño del código.
Rellene el archivo EXE con NOPs en el ensamblador.
Si desea aumentar el tamaño del archivo, agregue un archivo de texto al final del archivo ejecutable del tamaño requerido.
Solía hacer esto cuando los clientes se quejaban de pequeños exes. No se dieron cuenta de que los pequeños exes son tan profesionales como los grandes. De hecho, en algunos idiomas hay un comando bloat () para aumentar el tamaño de los ej., Generalmente en compiladores BASIC.
EDITAR: Encontró un enlace antiguo a un fragmento de código que la gente usa: http://www.purebasic.fr/english/viewtopic.php?f=12&t=38994
Si todo lo demás falla, aún podría crear un archivo fuente de lenguaje ensamblador donde tenga un número adecuado de sentencias de db que emiten bytes en el segmento de código, y vincular el objeto de código resultante a su programa como una extern "C" { ... } .
Es posible que deba jugar con el compilador / enlazador para evitar que el enlazador optimice el objeto de "código" ficticio.
Use #define para definir muchas macros que contienen cadenas de gran longitud, y use esas macros dentro de su programa en muchos lugares.
Utilice Boost y compile el ejecutable con información de depuración.
Utilice una gran variedad de datos constantes , como cadenas explícitas:
char *dummy_data[] = {
"blajkhsdlmf..(long script-generated random string)..",
"kjsdfgkhsdfgsdgklj..(etc...)...jldsjglkhsdghlsdhgjkh",
};
A diferencia de los datos variables, los datos constantes a menudo caen en la misma sección de memoria que el código real, aunque esto puede depender del compilador o del enlazador.
Edición: Probé lo siguiente y funciona en 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;
}
Tanto este código como su salida se compilan limpiamente.
char big[5*1024*1024] = {1};
Debe inicializarlo con un valor distinto de 0 o el compilador / vinculador puede optimizarlo.