Skalarni typy vs slozene typy
=============================
Backend nemusi vedet, ze jde o strukturu.

Rozpousteni struktur - prekladac si vsimne, ze ma LOKALNI promennou typu struktura a pokud se s tou strukturou nepracuje jako s celkem (pointry na strkturu), tak se ta struktura rozsype na kousicky - pristupu je se k jednotlivym promennym rovnou. U globalni struktury to nejde, protoze nezname vsechny pristupy k strukture. U pole se to nepouziva - je jich hodne (neni neprime adresovani registru).

Pouceni: U grafiky se pouzivaji vektory pevne velikosti - vetsina programatoru obaluje pole tridou. Pokud pojmenujeme polozky struktury a1, a2, a3, ..
tak chytrejsi prekladace umi strukturu rozbit na kousky, navic dokazi hodnoty dat do registru (u modernich prekladacu). 

Zarovnani instrukci
===================
Sirka sbernice az 192 bitu.

Intel: umime precist i z nezarovnane adresy instrukci, ale trva to dele.

* Fronend resi zarovnani instrukci v pameti
* Backend zaridi, ze zarovna struktury v ramci zacatku segmentu
* Runtime resi zarovnani zasobniku - i kdyz jen vracime nejakou hodnotu, tak musime mit na zasobniku delku nasobku 8.
  Na zasobniku je strategie:
    - liche -> sude (pridam jedno policko)
    - vkladam podle velikosti promennych postupne
      [ ][ ][ ][|][  ][  ][   ][|||][     ]       <--- || znaci pridana prazdna policka

Promenna
========
* V prekladacich to znamena (v backendech): lokalni promenne - protoze s tema se pracuje v zakladnich blocich, ...

f(int x)        <--- x nemuze byt porad v tom samem registru, protoze g bude chtit umistit na tento registr hodnotu 1.
{
  g(1)
}

Vyrazy:

x[0]

y

se prelozi pomoci ruznych instrukci.

* Pozn: Prekladac obecne nemuze rozhodnout, zda pristup: *p = neco ... vede na nejakou promennou v zakladnim bloku (je to neresitelny problem)
* Registry nemaji adresy, tudiz promenna "y" z vyrazu *p = &y; musi byt na nejakem pametovem miste.
* Promenne bez aliasu jsou kandidati na umistovani do registru.

Rozsah platnosti
* Zakladem je zjistovat platnost pro promenne bez aliasu (u promennych s aliseam se to umi taky nejak s nejakou presnosti - odhad shora)

| x = 1
| ... = x


| x = 2
| ... = x
  
"|" .. oznacuje oblast souvislosti, misto kde promenna zije, pouzije se prejmenovani:


| x = 1
| ... = x


| x' = 2
| ... = x'

Duvod: Nemusim promenne x a x' davat do jednoho mista v pameti, v registru, pokud neprejmenuju, tak musim!

SSA (Static-Single-Assignment)
==============================
* Snazim se dosahnout toho, abych do kazde promenne zapisoval na jednom miste (v kodu?)
* Priklad:

if (...)
  x = 1
else
  x = 2
  
cti(x)

==== zmenim na ===

if (...)
  x = 1
else
  x' = 2           <<< prejmenuji

cti(phi(x, x'))   <<<-- phi je magicka funkce, ktera mi vrati spravnou promennou



Linker
======
* Opravuji se adresy instrukci (o posunuti daneho modulu vuci celemu prekladanemu programu)

Spill code
==========
* Optimisticka alokace registru - verim, ze se mi vsechny promenne vejdou do registru, pokud se stane, ze se nevejdou, tak se zpetne opravi cteni a zapis pro dane promenne
* Priklad:
 
kod:
  add r1, r2    <-- r1 obsahuje promennou x, r2 obsahuje y
  
upravim na:

  mov r2, [=y]  <- navic muzu tuto instrukci strcit obcas o mnoho vyse (napr. desitky instrukci na jedno cteni z pameti)
  add r1, r2

  - Nevyhodne pokud mam nedostatek registru, protoze posunutim "mov" nahoru potrebuji registr r2 dele.
  - Proto si vyhradim rezervni registry, coz ale zase nemusi byt dostatecne setrne..
LOAD/STORE kod



"backendu u je to burt" :-)