Velmi malý "hello world" bez standardní knihovny

9.2.2022 03:18 | Přečteno: 10309× |

Ze prče jsme zkoušeli s kámoši vymyslet co nejmenší binárku, co vypíše "hello world!". Nabízím k volnému použití či inspiraci, k čemu jsme došli; určitě by šlo ještě přitlačit šašením s hlavičkami ELFu, ale praktický smysl by to asi nemělo; co mě zaujalo, že i bez standardní C knihovny jde poměrně bezbolestně napsat spustitelný, nijak aberantní kód pro Linux; s trochou snahy by takto šlo vyrobit podstatně složitější program vlastně stejně jako na mikrokontrolérech. Jak moc je to praktické, to nevím.

Tato varianta je pro x86-64, protože inline assembler; pro jinou platformu to bude velmi podobné, jen registry a čísla předávaná kernelu se budou lišit (dost mě udivilo, že na 64-bitovém Intelu má syscall exit() číslo 60, zatímco na x86 je to 1).

(Děkuji tímto Mačkočíčkovi za linker script a zušlechtění mého C-čkového kódu. )

tinyhello.c:

#include <stdint.h>

int sys_write(int fd, char const* text, uint32_t length) {
    uint64_t retval;
    asm volatile (

        /* SYSCALL instruction invokes the kernel */
        "syscall"

        /* return value will be read from rax */
        : "=rax"(retval)

        /* where the input arguments should be placed */
        :   "a"((uint64_t)1),   /* eax = syscall number */
            "D"(fd),            /* argument 1 (fd) goes to rdi/edi */
            "S"(text),          /* argument 2 (text) goes to rsi/esi */
            "d"(length)         /* argument 3 (length) goes to rdx/edx */

        /* registers that may contain garbage after the call - for syscalls, they are rcx, r11 */
        : "rcx", "r11"
    );
    return retval;
}

void sys_exit() __attribute__((noreturn));
void sys_exit() {
    asm volatile (
        "syscall"
        :
        : "a"((uint64_t)60), "D"((uint32_t)0)
        : "rcx", "r11"
    );
    for(;;);    /* emergency stop */
}

void _start() {
    sys_write(1, "Hello world!\n", 13);
    sys_exit();
}

Lze přeložit jednoduše s gcc tinyhello.c -o tinyhello --static -nostdlib s tím, že výsledný ELF obsahuje hodně balastních sekcí a má cca 9 KiB nestripnutý. Pro zahození sekcí, které tady nejsou potřeba, linker script:

tinyhello.lnk:

OUTPUT_FORMAT(elf64-x86-64)
ENTRY(_start)

SECTIONS
{
    . = SEGMENT_START("text-segment", 0x400000) + SIZEOF_HEADERS;
    .text : {
        *(.text);
        *(.rodata*);
    }

    /DISCARD/ : {
        *(*);
    }
}

Překládá se potom s gcc tinyhello.c -o tinyhello --static -nostdlib -Ttinyhello.lnk a výsledek má 880 bajtů nestripnutý.        

Komentáře

[k8o]

Pěkné, díky :)

[Leo]

+1 Dobra prace. Co tak jeste jeden challenge a zbavit se stdint.h?

[Guox]

to byl ale ten nesmyslny bulvarni nadpis zpravdivel, to po OP nemuzes chtit

[kralyk z abclinuxu]

Tato varianta je pro x86-64, protože inline assembler

Dá se to napsat i tak, že to podporuje více platforem zaráz. Před nějakou dobou jsem si s tím hrál a zde je výsledek, který podporuje x86-64 a ARM (nebo aspoň 'běžné' ARMy, nějaký specielní možná fungovat nebude):

#include <stdint.h>

const uint64_t _start[] __attribute__((section(".text"))) = {
    0xe3a00001909032eb, 0xe3a0200ce28f1014,
    0xef000000e3a07004, 0xe3a07001e3a00000,
    0x6c6c6548ef000000, 0x0a214d5241202c6f,
    0x18ec834800000000, 0x4800000045058b48,
    0xa20fc03148240489, 0x0c24548908245c89,
    0x142444c710244c89, 0x01c0c74800000a21,
    0x0001c7c748000000, 0x480124748d480000,
    0x050f00000015c2c7, 0x480000003cc0c748,
    0x6c654820050fff31, 0x00000000202c6f6c,
};

Kompiluje se pomocí gcc -static -nostdlib

Přeji příjemnou zábavu :)

[deda.jabko]

Tato varianta je pro x86-64, protože inline assembler

U prvni verze jsem si rikal, jestli by to nebylo citelnejsi psat rovnou v assembleru... Ale napad vzit binarku a prelozit ji s gcc na binarku je dost originelni, to uznavam. ;-]

[kralyk z abclinuxu]

Ale napad vzit binarku a prelozit ji s gcc na binarku je dost originelni, to uznavam. ;-]

Ten není můj, ten je odsud :) Můj je jen ten s tou platformní vidličkou...

[ehmmm]

Muzu se prosim nechat poddat a videt assembler od tohodle? :)

(Oni to zrejme budou dva assemblery, ze?)

[kralyk z abclinuxu]

Je to tak :)

[ehmmm]

Dik, taky dobry cteni.

[❗Červivý Hřib krade❗]

supr stromeček žlutej :P :D ;D ;D

[Xerces]

Náčelníku? Možná to vypadá, že pořád jenom kritizuju, ale tohle vypíše Hello, a označení CPU a ne Hello, world! Tak to jen tak pro úplnost.

[Petr]

"ze prče"?

Fake and gay bluebear, originál uměl česky!

[Petr Tomášek]

"ze z prče"?

[_]

gay byl vždycky

[Petr Tomášek]

A kolik to dělá B po striptýzu?

[Bluebear]

592 byte (asi se může trochu lišit na různých strojích podle toho, jak se chová linker).

[Josef Kufner]

V dobách DOSu by to bylo na pár bajtů. Formát COM žádné hlavičky neměl, to se prostě nasypalo do CPU tak, jak to bylo na disku. Pár movů s int 21h a bylo to. Ani nepotřebuješ překladač, prostě to nacvakáš v hexaeditoru.

Dnes se do podobné situace člověk dostane akorát když si hraje s jednočipy. To pak má třeba půl kilobajtu paměti, kam se potřebuje vejít s nějakým netriviálním výpočtem a ve zbytku paměti má hromadu dat.

[jiwopene]

s/do CPU/do paměti/

Jinak před nějakou dobou tu byl odkaz na toto.

[Bluebear]

Jistě - byly to tehdy jednodušší a snad šťastnější časy - ale DOS byl taky celkově jednodušší a měl méně schopností.

[OldFrog {Ondra Nemecek}]

Jste málo radikální - nejmenší program je ten, který nic nedělá Koncepční otázka ovšem je, zda po něm chtít, aby se spustil

[Heron]

Přesně tak. Bez assembleru bych to nedal, ale com by měl pár B.

[jiwopene]

GNU Assembler, linker script podobný, 376 bajtů (jako ELF).

        .text
        .code64

        .globl _start
_start:
        movb    $1, %al          /* syscall num */
        movw    $1, %di          /* file descriptor */
        movq    $hello_str, %rsi /* text */
        movq    $(hello_str_end - hello_str), %rdx /* length */
        syscall
        movb    $60, %al
        xorw    %di, %di
        syscall

        .data
hello_str:
        .ascii  "Hello, World!\n"
hello_str_end:

[kvr]

Tak nějak. Kdysi jsem se dostal na cca 400 bytes, ale byl jsem trochu slušnější a inicializoval jsem celé 32-bit proměnné, nejenom spodních 8 bitů. Matně si vzpomínám, že linker script jsem nepotřeboval, stačil snad nějaký option ke gcc, aby vynechalo standardní linker script, ale už si to moc nepamatuju.

[z_sk]

A ako to prekladáš?

[jiwopene]

V podstatě stejně.

as -64 hello.S -o hello.o && ld --omagic -s -x -static -T script.ld hello.o

(tj. x86_64, ne debugovací symboly, strip a statické)

Linker script stejný, jenom místo .rodata tam je .data.

[Aleš]

To je fakt dementní jazyk. není důvod, aby to mělo víc než dvacet bajtů.

[Wirth]

To neni jazykem ale operacnim systemem. Treba v DOS staci do DX dat "Hello World", do AH volani zabudovane funkce "print" (tusim AH,9) a zavolat preruseni INT 0x21. A pak jeste dat vedet ze koncime pres AH 0x4c a opet INT 0x21. Tohle v linuxu das s par instrukcema navic protoze jdes pres stdout (BX,1) a sys_write (BX,4) a tusim jeste musis i dat vedet jak dlouhy stream tam pujde (DX,delka) a samotny stream(CX, pointr na "Hello World"). No a linux ma INT 0x80 a sys_exit je neco podnyho jako v DOSu (AX,1; BX,0).

[...]

je to jazykem, zkus si to v javascriptu

[nadtržítko]

Kdybys nemel v hlave slamu tak bys vedel, ze skriptovaci jazyky tu tahat co? Tu tahat nebudeme. Nebudeme proc? Protoze nemaji linker. A kdyz ho nahodou i maji tak co? Tak je ceckovy!

[...]

Kdybys neměl v hlavě nasráno, tak bys pochopil, že celý ten linker a další c hovna jsou k ničemu a javascript je mnohem efektivnější a hotový program je menší.

[plostenka]

Tak ukaz svoji JS binarku, nebo procesor/ASIC na kterem bezi JS nativne.

[...]

K čemu binarku? Uvażuješ jako dinosaurus.

[plostenka]

Tak predved ten ASIC co zpracovava JS nativne, bez binarky.

[...]

to umi kazdy prohlizec

[ELF]

https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html

Tohle je 45 bajtu (avsak to predpoklada Linux jako behove prostredi).

Hello World by byl vetsi (tohle je pouze return 42;).

[ehmmm]

Kdyby me nevyrusil kolega, tak bych mohl rict, ze jsem to precetl jednim dechem. Bomba!

Celkove se tady objevila skvela a pro me velmi prinosna diskuze.

[z_sk]

Tvoj kód/preklad	864 B
+ moje úpravy/preklad	736 B
Ušetrene:	131 B (14,8 %)

P.S.: Velikosť súboru zistíš: du -b FILE.

[z_sk]

Tvoj kód/preklad	864 B
+ moje úpravy/preklad	496 B
Ušetrene:	368 B (42,59 %)

[problem solved]

echo Hello world

[❗Červivý Hřib krade❗]

tttttssss echo má nějakejch 40kb :O ;D

[Xerces]

Nj., ale kolik má to jádro Linuxu na kterým se ty vytuněný binárky pouštěj.

[Petr Tomášek]

Chtěl jsi spíš říci: „kolik má bash“?

Linuxové ňadro volá ten 400-bytový program v assembleru...

[kralyk z abclinuxu]

tttttssss echo má nějakejch 40kb :O ;D

U mě taky... Ale ten se pravděpodobně nepoužije, typicky se použije echo zabudovaný přímo v shellu...

[❗Červivý Hřib krade❗]

kde jakoby vubec končí c a začíná asm :O :O

[_]

c je asm a trocha syntaktickeho cukru

jazyk pro psychopaty

[xxxs]

dufam, ze sa nedaju zahanbit ani fanusikovia electronu.

[xkucf03]

V čem je problém? Kdybys chtěl programovat tímhle způsobem, tak bys vyzobal/reimplementoval různé části standardní knihovny a řešil by sis přenositelnost sám. Teoreticky kdyby standardní knihovna byla moc velký moloch a potřeboval bys z ní jen nějakých 10 %, tak by to třeba smysl dávalo, ale typicky z ní budeš potřebovat větší část a navíc je tu ta přenositelnost… řešit tyhle věci v kódu aplikace mi přijde nesmyslné. Jako ukázka je to fajn, ale… jinak už by dávalo větší smysl to řešit na úrovni jazyka (tzn. úplně obejít céčko a místo něj mít něco jiného, co se napojuje na systémová volání).