Ross Burton: Embedding Binary Blobs With GCC
For a long time I've wanted to know how to embed binary blobs into
executables. This would be most useful for files like Glade and and UI
Manager definitions, which are required for a given program to work at all
but either cannot be embedded as a string literal (Glade) or can be but is
annoying (UI Manager). I finally asked the Interweb, and Daniel
Jacobowitz replied with some pointers. It turns out that doing this is
remarkable simple.
First, a caveat. This probably requires GNU ld, which may or may not be a
deal breaker for many people.
First, create a data file. Let's call it foo.txt, and put some text in it.
Hello, World!Using ld this can be read in as a plain binary blob, and then written as a standard relocatable ELF object.
ld -r -b binary -o foo.o foo.txtNow we have a standard ELF object with the data and some useful symbols defined. objdump will show you the contents.
$ objdump -x foo.o
foo.o: file format elf32-i386
Sections:
Idx Name Size VMA LMA File off Algn
0 .data 0000000d 00000000 00000000 00000034 2**0
CONTENTS, ALLOC, LOAD, DATA
SYMBOL TABLE:
00000000 l d .data 00000000 .data
0000000d g .data 00000000 _binary_foo_txt_end
0000000d g *ABS* 00000000 _binary_foo_txt_size
00000000 g .data 00000000 _binary_foo_txt_start
Here we see 13 bytes of data, and a symbol which contains the address of
the data. This is all we need to access it from a C program.
#include <stdio.h> extern char _binary_foo_txt_start[]; int main (void) puts (_binary_foo_txt_start); return 0;Now if we compile this and link it against the generated object, we'll have a binary.
$ gcc -o test test.c foo.o $ ./test Hello, World!Hooray! One small problem which alert people should have noticed: the string itself is in the .data section, which is read/write. For my use, I want it to be read-only data in the .rodata section so that it isn't copied for every instance of the application. As far as I know, this isn't possible with ld but objcopy will let us rename sections on the fly.
$ objcopy --rename-section .data=.rodata,alloc,load,readonly,data,contents foo.o foo.o $ objdump -h foo.o ... 0 .rodata 0000000d 00000000 00000000 00000034 2**0Excellent, problem solved. If you want to download this sample, I have a tarball. Many thanks to Daniel Jacobowitz for pointing out how to achieve this. Update: note that any data embedded in the binary like this won't be terminated with a NULL. This is obvious in hindsight, but due to luck my example still worked. There might be a way of asking objcopy to append a 0 to the end of the data, but if not always remember to use the start and end pointers or size instead of just the start, or append a NULL yourself before converting to an ELF. NP: (), Sigur Rós
I've always been proud of the "vidio" game, which is the first game shown
above. It'd give Pong a run for its money in simplicity, and has gameplay I
still enjoy (for up to 5 minutes at a time). You're the green dot, which is
flying from left to right. Each time it reaches the right side of the
screen, it wraps back to the left -- but leaves a blue wall behind. Crash
into the wall and you lose a life. Sometimes other dots appear that you can
pick up to get new lives.
This sounds easy, but it's not, mostly because the Atari joystick (or my
code for reading it) is not very precise, so it's hard to line up to
exactly the right place on the screen to go through a small hole in the
wall.
In contrast to that piece on innovation, the "jump" game is a pretty
generic platformer, jump over the water and shoot the enemy that's crawling
along the ceiling. It's also a bit buggy.
I took a look at the code, but the bug on line 200 isn't very obvious,
whatever it is. This is how everyone's old code looks to them after 20
years ... right?
My version of Tetris for the Atari. It looks a lot better on a real TV
tube. Two fun things in writing this were that I couldn't figure out how
to program it to rotate the blocks on the fly -- so I just wrote out data
with every possible rotation for every block. Also, Atari BASIC lacks
arrays, so it uses strings for storing the game state.
