🚀 go-pugleaf

RobertGawron pisze:
> Witam,
> 
> swego czasu napisałem prościutki język programowania, który kompilował
> się do kodu pośredniego, prostego asemblera, później wykonywanego
> przez maszynę wirtualną. Teraz chciałbym ten kod pośredni kompilować
> do pliku wykonywalnego, który mogę odpalić pod Linuksem, szukałem
> trochę, wiem już mniej więcej jak działają pliki ELF ale utknąłem na
> czy ma jakąś konkretną nazwę proces zamiany nazw
> mnemoników na wartość hexową, która później jest zapisywana do pliku
> ELF, w jakiejś tam sekcji?
Assemblacja? (Assembling) Chociaż przy dzisiejszych (makro) assemblerach 
można mówić chyba już o kompilacji.

Wydaje mi się, że chcesz wygenerować kod assemblerowy np. dla nasm'a 
albo masm'a. potem możesz skompilować to do .o i zlinkować z 
istniejącymi obiektami (np jakieś procedury startowe) albo bezpośrednio 
do elfa.

-- 
Pozdrawiam
Michoo

Witam,
dzięki za odpowiedź.

Zamiast generować z pliku z kodem asemblera (o składni, jaką mam) plik
o składni NASM'a, czy innej i kompilowania go normalnie, wolałbym
napisać swój kompilator, który pobiera ten plik (z moją składnią)
asemblera i tworzy plik wykonywalny (albo pliki, które później się
linkuje, już normalnie).

Czytam teraz swój wcześniejszy post i widzę, że jest trochę
zagmatwany, więc napiszę raz jeszcze.


Przykładowy skompilowany kod:

rgawron@foo:/opt/asm/nasm$ objdump -d foo

foo:     file format elf32-i386

Disassembly of section .text:

08048060 <.text>:
 8048060:       31 c0                   xor    %eax,%eax
 8048062:       31 db                   xor    %ebx,%ebx
 8048064:       bb 37 00 00 00          mov    $0x37,%ebx
 8048069:       b8 05 00 00 00          mov    $0x5,%eax
 804806e:       01 d8                   add    %ebx,%eax
 8048070:       89 c3                   mov    %eax,%ebx
 8048072:       b8 01 00 00 00          mov    $0x1,%eax
 8048077:       cd 80                   int    $0x80

Chodziło mi o drugą i trzecią kolumnę (licząc od 1 ;-)), skąd ludzie,
którzy tworzą kompilatory wiedzą, że instrukcję int 0x80 trzeba
przetłumaczyć na 0xcd 0x80.

W międzyczasie znalazłem odpowiedź na to pytanie (aczkolwiek nie wiem,
czy pełną) - http://www.logix.cz/michal/doc/i386/chp17-03.htm

Asembler, który mam jest b. prosty, więc liczę, że pójdzie to w miarę
szybko, jakby ktoś chciał o nim poczytać, to tu jest link (
http://rgawron.megiteam.pl/2009/04/23/vm/ ) (mam nadzieję, że nie
będzie mi to poczytane za spam).

Trudno mi było znaleźć info w sieci, bo co bym nie wpisał w
wyszukiwarce to dostawałem linki do kursów uczących asemblera albo
opisujących jak skompilować program.

Dzięki za odpowiedź, jeśli będziecie mieli jakieś info, na co zwrócić
uwagę, czy linki do jakiś książek albo kodów źródłowych to też chętnie
przejże.

pozdrawiam
Robert Gawron

RobertGawron pisze:
> Witam,
> dzięki za odpowiedź.
> 
> Zamiast generować z pliku z kodem asemblera (o składni, jaką mam) plik
> o składni NASM'a, czy innej i kompilowania go normalnie, wolałbym
> napisać swój kompilator, który pobiera ten plik (z moją składnią)
> asemblera i tworzy plik wykonywalny (albo pliki, które później się
> linkuje, już normalnie).
> 
> Czytam teraz swój wcześniejszy post i widzę, że jest trochę
> zagmatwany, więc napiszę raz jeszcze.
> 
> 
> Przykładowy skompilowany kod:
> 
> rgawron@foo:/opt/asm/nasm$ objdump -d foo
> 
> foo:     file format elf32-i386
> 
> Disassembly of section .text:
> 
> 08048060 <.text>:
>  8048060:       31 c0                   xor    %eax,%eax
>  8048062:       31 db                   xor    %ebx,%ebx
>  8048064:       bb 37 00 00 00          mov    $0x37,%ebx
>  8048069:       b8 05 00 00 00          mov    $0x5,%eax
>  804806e:       01 d8                   add    %ebx,%eax
>  8048070:       89 c3                   mov    %eax,%ebx
>  8048072:       b8 01 00 00 00          mov    $0x1,%eax
>  8048077:       cd 80                   int    $0x80
> 
> Chodziło mi o drugą i trzecią kolumnę (licząc od 1 ;-)), skąd ludzie,
> którzy tworzą kompilatory wiedzą, że instrukcję int 0x80 trzeba
> przetłumaczyć na 0xcd 0x80.
Nazywa się to "opcode" i jest w dokumentacji procesora.
Np. http://developer.intel.com/design/pentiumii/manuals/243191.htm

> 
> W międzyczasie znalazłem odpowiedź na to pytanie (aczkolwiek nie wiem,
> czy pełną) - http://www.logix.cz/michal/doc/i386/chp17-03.htm
To jest bardzo stary zestaw - szybko patrząc brakuje choćby cmpxchg, ale 
powinien do Twoich zastosowań starczyć.

> 
> Asembler, który mam jest b. prosty, więc liczę, że pójdzie to w miarę
> szybko, jakby ktoś chciał o nim poczytać, to tu jest link (
> http://rgawron.megiteam.pl/2009/04/23/vm/ ) (mam nadzieję, że nie
> będzie mi to poczytane za spam).
Na obrazku brakuje jeszcze bytecode->jit->"machine code" biorąc pod 
uwagę jak działa większość współczesnych środowisk.
> 
> Trudno mi było znaleźć info w sieci, bo co bym nie wpisał w
> wyszukiwarce to dostawałem linki do kursów uczących asemblera albo
> opisujących jak skompilować program.
> 
Imo pisanie kompilatora obsługującego pliki elf dla tak małego języka to 
lekki overkill (nawet g++ generuje kod assemblerowy, który potem jest 
kompilowany)

Ale jak chcesz się bawić to poszukaj info o budowie pliku elf - ona nie 
jest aż tak trudna. Wtedy twój assembler będzie generował plik *.o, 
który można będzie zlinkować za pomocą ldd z bibliotekami startowymi i 
dostać wykonywalnego elfa.

-- 
Pozdrawiam
Michoo

Wielkie dzięki za wszystkie informacje i porady, przydadzą się.

> Na obrazku brakuje jeszcze bytecode->jit->"machine code" biorąc pod
> uwagę jak działa większość współczesnych środowisk.

Racja, poprawię obrazek albo dopiszę to pod spodem, thx.

> Imo pisanie kompilatora obsługującego pliki elf dla tak małego języka to
> lekki overkill

Chcę zobaczyć z bliska, jak to działa.

pozdrawiam
Robert Gawron

> Zamiast generować z pliku z kodem asemblera (o składni, jaką mam) plik
> o składni NASM'a, czy innej i kompilowania go normalnie, wolałbym
> napisać swój kompilator, który pobiera ten plik (z moją składnią)
> asemblera i tworzy plik wykonywalny (albo pliki, które później się
> linkuje, już normalnie).

Dużo roboty. Bardzo dużo roboty. Nie zdajesz sobie sprawy, ile.

Ale.. powodzenia ;-)


-- 
Azarien

Cześć,

FYI drążąc dalej temat napisałem *prosty* kompilator:
* jego możliwości to obsługa operacji ALU, stosu, przerwań,
generowanie wewnętrznych procedur
* kompiluje kod dla Linuksa, dla 32bitowych, zgodnych z i386
* napisany w C, obiektowo
* adres projektu: http://github.com/RobertGawron/l33tlang
* HOWTO: http://rgawron.megiteam.pl/2010/03/06/simple-32bit-intel-linux-compiler/

pomyślałem, że może się to kiedyś komuś przydać, bo kod jest
siermiężnie prosty, a przy tym w miarę dobry i łatwo da się go
rozwijać o nowe funkcje. Jakbyście mieli uwagi, to chętnie wysłucham.

pozdrawiam serdecznie
Robert Gawron