A számítógépes fordítók mikor lefordítják a kódot gépi kódra bonyolítják azt?

Mivan?? Te érted, hogy mit akarsz kérdezni?

Amikor gépi kódot fordítunk egy forráskódból, akkor lefordítjuk a processzor által érthető nyelvezetre.

"Igazából a kérdés az hogy a gépi kód bonyolultabb -e a forrás kódnál?"

Erre így nem lehet válaszolni. Mit jelent a bonyolultság? A magasabb szintű absztrakciók alacsonyabb szintűre képződnek le, miközben a forráskódból tárgykód lesz (forráskódban lehetnek pl. osztályok, de a processzor nem ismeri az osztály fogalmát). Ilyen szempontból egyszerűbb, primitívebb a tárgykód.

De mivel primitívebb utasításokból áll össze, ezért mondhatni komplexebb is.

"De most úgy látom hogy igen és hogy lényegében amikor programozik valaki akkor megokosítja a gép csak nem mindegy hogy mennyire kell az embernek a gép szájába rágni a dolgokat és fordítva.Hogy mennyire kell a gépnek az emberbe hatolnia ?"

A gépnek az emberbe hatolnia? A gép nem hatol az emberbe...

Értem, hogy mit nem értesz.

A gépi kód az alap, sokkal egyszerűbb mint a magasabb szintű programnyelvek. Legalábbis abban az értelemben, ahogyan TE érted.

A gépi kód "bonyolizálásával" alkotják a magasabb szintűeket.

Minden számítógép processzorának van egy szerkezete. Ez a szerkezet, pontosabban, ennek milyensége határozza meg, hogy a CPU miként hajtja végre azokat az utasításokat, amelyeket egyáltalán ismer. Ezeknek az utasításoknak az összessége egyébként maga a gépi kód.

A számítógép CPU-ja nem is képes másra, csak a gépi kódot tudja futtatni.

Ezek a gépi kódú utasítások általában (!) elemi utasítások, azaz, nem bonthatók fel további utasításokra (bár előfordul kivétel is). Az ilyen utasításokból sok van, de többnyire minden utasítás csak egy nagyon egyszerű dolgot valósít meg.

Ez annyit jelent, hogy míg pl. egy magas szintű nyelvben az INC(rement) utasítás egy kulcsszó és egy (vagy két) paraméter, addig ugyanennek a gépi kódja állhat hat, vagy nyolc-tizenkét elemi utasításból is.

A fordítók leglényegibb feladata az, hogy a magas szintű nyelvek utasításait és a magas szintű nyelven írt forráskódban előforduló kifejezéseket (A = B + (C * D)) elemi utasításokra (gépi kódra) bontsa fel. Természetes, hogy míg a magas szintű nyelv valamely ciklusa, vezérlő szerkezete egy-két kulcsszó és paraméter, addig ugyanez gépi kódban akár ötven-száz utasításból is állhat.

Egy növekményes (for) ciklus, vagy egy CASE szerkezet még üresen is több tíz elemi, gépi kódú utasításból áll.

A fordítók nem bonyolítanak, inkább egyszerűsítenek, legalábbis a jobbak. Ez az optimalizálás, aminek vannak szintjei. A legegyszerűbb optimalizálás nem több, mint az adatok mozgatásának csökkentése, mert alaphelyzetben egy sima, egymenetes (tehát, nem intelligens) fordító úgy fordít, hogy elég sok fölös adatmozgatás lesz a gépi kódban.

Pl. előfordulhat, hogy az (A + B) * C kifejezés esetében elvégzi az A és a B összeadását, az eredményt a regiszterből kitolja a memóriába, azután onnan vissza is teszi a regiszterbe és csak utána fogja szorozni C értékével. Ez már két fölösleges (adat ki, adat be) utasítás.

Ekkor egy intelligens fordító nem mozgatja a memóriába az A + B eredményét, hanem betölti a C értékét és szoroz.

Persze ez függ a processzor architektúrájától is. Mert van, amelyik így, van amelyik meg úgy hajtja végre ugyanazt a műveletet, vagy műveletsort.

Akad, amelyik sok regiszterrel rendelkezik, akad amelyik meg kevéssel.

Akad olyan is, amelyik még szorozni sem tud, ez összeadások sorával valósítja meg a szorzás műveletét, ami sokkal lassabb lesz, mint az olyan, amelyiknek van szorzó áramköre.

Ez az összeadás,

a = 6;

b = 2;

c = a + b;

így néz ki, egy szimpla, de trükkös CPU* gépi kódjában:

MOV AX,6

MOV [A],AX

MOV AX,2

MOV [B],AX

MOV AX,[A]

PUSH AX

MOV AX,[B]

POP BX

ADD AX,BX

MOV [C],AX

Lám. Három sorból lett tíz.

* Ez egy -saját- VM két regiszteres (AX,BX) virtuális processzora. Érdekessége, hogy az adatmozgatást stack-kel oldja meg. Ez sokat egyszerűsít a CPU szerkezetén és az ADAT-út is a lehető legrövidebb.

A kódban az

[A],

[B] és

[C] eredetileg az A,B,C változók (literálok) memóriahelyei, de kicseréltem őket változónevekre, az érthetőség kedvéért.

Egy loop példa:

A = 1;

While (A < 4) do A = A + 1;

és a két sor - fordító által generált - assembly kimenete:

MOV AX,1

MOV [A],AX

LBL0:

MOV AX,[A]

PUSH AX

MOV AX,4

POP BX

SUB BX,AX

MOV AX,BX

OR AX,AX

JNZ LBL1

JMP END

LBL1:

MOV AX,[A]

PUSH AX

MOV AX,1

POP BX

ADD AX,BX

MOV [A],AX

JMP LBL0

END:

A jobb olvashatóság kedvéért:

01 MOV AX,1

02 MOV [A],AX

LBL0:

03 MOV AX,[A]

04 PUSH AX

05 MOV AX,4

06 POP BX

07 SUB BX,AX

08 MOV AX,BX

09 OR AX,AX

10 JNZ LBL1

11 JMP END

LBL1:

12 MOV AX,[A]

13 PUSH AX

14 MOV AX,1

15 POP BX

16 ADD AX,BX

17 MOV [A],AX

18 JMP LBL0

END: