AsmJit - Podpora pro 64 bitů (diskuse)

[zde]

Paradoxem je, že 8 a 16 bitovou hodnotu načíst/uložit lze

???

[Deleted [8409]]

Udělal jsem chybu, 8 bit samozřejmě nelze ani v x86:) (Opraveno).

x86:
push ax // lze
push eax // lze

x64:
push ax // lze
push eax // nelze
push rax // lze

[YYY]

Je to moc pekne. Preju hodne stesti pro dalsi vyvoj

[backup]

Nedávno jsem napsal zápisek o knihovně AsmJit, díky které je možné dynamicky generovat a spustit x86 assembler v C++. Knihovna byla od samého začátku psaná pro 32 bitovou X86 architekturu a kód neobsahoval ani jeden řádek, který by do budoucna ulehčil portování na 64 bitů. V dnešní době je ale podpora pro 64 bitů povinnost. Rekl bych, že se jedná o hodně důležitý prvek pro životnost jakéhokoliv projektu.

Úvod k X64

Architektura X64 nebyla navržená úplně od začátku, je to zjednodušeně jen obohacený 32 bitový model o 64 bitové adresy, 64 bitové operandy a 16 nových registrů. FPU je prakticky nezměněné, SSE instrukce jsou obohacené o 8 nových SSE registrů (XMM8 až XMM15) a klasické instrukce jsou obohacené o dalších 8 GP (general purpose) registrů (R8 až R15). U GP registrů je velice zajímavé, že to nejsou jen 64 bitové varianty, ale jako klasická architektura X86 obsahují i 32 bitové, 16 bitové a 8 bitové varianty.

Seznam nových registrů

• RAX, RBX, RCX, RDX, RSI, RDI, RSP, RBP - rozšíření klasických registrů (64 bitové)
• R8 až R15 - nové 64 bitové registry
• R8D až R15D - nové 32 bitové registry
• R8W až R15W - nové 16 bitové registry
• R8B až R15B - nové 8 bitové registry
• XMM8 až XMM15 - nové 128 bitové SSE registry.

Některé registry spolu sdílí společný prostor. Například změnou R8B registru se modifikují registry R8W, R8D a R8. Tento způsob používá X86 architektura už od začátku své existence a v programování se dá celkem dobře využít.

Kódování nových registrů a 64 bitový mód

Architektura X86 a kódování instrukcí je podle mě jeden velký zmatek. Držení zpětné kompatibility a postupné přidávání nových instrukcí způsobilo, že jen velmi těžko se hledá prostor pro další instrukce. To samozřejmě způsobilo, že aby bylo možné navrhnout 64 bitový mód, bylo potřeba některé (dnes nepoužívané nebo používané málo) instrukce vyhodit a popřemýšlet o napasování nových. Rozšíření registrů, které je popsané v minulém odstavci má totiž jeden velký háček. Jak kódovat 16 registrů, když pro kódování registru jsou v architektuře X86 použité pouze 3 bity (3 bity = 8 kombinací = počet registrů X86, MMX, SSE)? Návrháři vymysleli tzv. REX prefix. Jedná se o prefix, do kterého můžete vložit 4 upřesňující bity před každou instrukci.

REX prefix je BYTE, který obsahuje bity W, R, X, B:

• W - obsahuje velikost operandu (Width) (0 = 32 bitový, 1 = 64 bitový)
• R - upřesňuje Register field (ModRM) (0 = index 0-7, 1 = index 8-15)
• X - upřesňuje indeX field (SiB) (0 = index 0-7, 1 = index 8-15)
• B - upřesňuje Base field (ModRM/SiB) (0 = index 0-7, 1 = index 8-15)

(Index field a base field se používá pro ukazatele, pokud je operace jen registr/registr, tak se index ignoruje a base znamená zdrojový registr)

REX prefix tedy umožňuje použití nových registrů a pro 64 bitové operace se musí použít skoro vždy (v Intel manuálu je to napsané jako promování (povýšení) instrukce - povýšíte ji do 64 bitového režimu). Zakódovat REX prefix je jednoduché (REX = 0x40 | (W << 3) | (R << 2) | (X << 1) | B). Problém byl s číslem 0x40, protože je to opkód pro jednu variantu instrukcí INC a DEC (variant existuje ale více). Architektura X64 tedy umožňuje používat jak 32 bitové, tak 64 bitové operace. Ale aby v tom nebyl háček Některé instrukce jsou povýšené na 64 bitů i bez REX prefixu. Jsou to například instrukce PUSH a POP, které slouží k manipulaci se zásobníkem. Tyto instrukce se nadají přepnout do 32 bitového režimu a na zásobník tak není možné uložit/načíst obsah 32 bitového registru. Paradoxem je, že 16 bitovou hodnotu načíst/uložit lze (a samozřejmě 64 bitů).

REX prefix má ještě další háček. Architektura X86 obsahuje více možností, jak prefixovat instrukce. Některé instrukce se pomocí prefixu 0x66 přepínají do 16 bitového režimu a některé MMX/SSE funkce používají speciální prefix 0xF3, 0xF2 a 0x66, který se ovšem v manuálech zapisuje jako opkód instrukce. Takže například pro instrukci psbsb(), kde opkód je v manuálu v podobě 0x66 0x0F 0x38 0x1C se REX prefix musí vložit mezi 0x66 a 0x0F.

Implementace v AsmJit

Když jsem začal vytvářet knihovnu AsmJit, vycházel jsem hlavně z kódu ve V8, který je čistě 32bitový. Experimenty pro podporu 64 bitů začaly pár dní zpět, kdy jsem se rozhodl počíst si Intel SW Developer Manual, a začal jsem studovat, co to ten REX prefix vlastně je, a co všechno je potřeba udělat. Největší problém byl v návrhu generování instrukcí, kdy skoro každá instrukce vypadala nějak takto:

  //! @brief Packed Shuffle Bytes (SSSE3).
  void palignr(const XMMRegister& dst, const Op& src, int imm8)
  {
    ASMJIT_ASSERT((src.op() == OP_REG && 
                   src.regType() == REG_SSE) || 
                  (src.op() == OP_MEM));
    if (!ensureSpace()) return;

    emitByte(0x66);
    emitByte(0x0F);
    emitByte(0x3A);
    emitByte(0x0F);
    emitOp(dst.regCode(), src);
    emitByte(imm8 & 0xFF);
  }

Pro mě to bylo velmi čitelné, věděl jsem přesně, z jakých částí se instrukce skládá a v jakém pořadí. Napsat ale kód pro REX prefix ke každé instrukci by vedlo jen k nepřehlednosti, tak jsem musel návrh změnit. Napsal jsem pár funkcí, které vygenerují kompletní instrukci ze vstupu, který obsahuje opkódy a operandy. Kód se tedy změnil ve většině případech do tohoto tvaru:

  //! @brief Packed Shuffle Bytes (SSSE3).
  void palignr(const XMMRegister& dst, const Op& src, int imm8)
  {
    ASMJIT_ASSERT((src.op() == OP_REG &&
                   src.regType() == REG_SSE) || 
                  (src.op() == OP_MEM));
    emitMMi(0x66, 0x0F, 0x3A, 0x0F, dst.regCode(), src, imm8);
  }

Funkce emitMM/emitMMi (používá se pro MMX a SSE) emituje kompletní binární kód instrukce. První parametr je prefix (protože REX prefix se dává až za tento prefix), další parametry jsou opkód instrukce, zdrojový registr, operand, a popřípadě 8 bitové upřesňující číslo. Pokud je prefix nebo první opkód nula, tak se nepoužije (instrukce mají totiž různou délku opkódů).

Toto byl ten lepší případ, některé instrukce jsem musel předělat ručně, takže korektnost všech instrukcí ukáže až čas. Výhoda v AsmJit jsou asserty, které kontrolují vstupní parametry, minimalizuje se tím šance, že vám některá funkce vygeneruje neplatný opkód.

Podpora pro 64 bitů ale neznamenala jen použít REX prefix. Některé části kódu jsem musel přepsat tak, aby bylo možné používat i 64 bitové proměnné. Starý kód používal na hodně místech int, protože se jednalo u 32 bitový X86 assembler. Nový kód používá typ SysInt, který je 32bitový nebo 64bitový podle cílové architektury (použil bych long, ale ten je pod Windows 32 bitů vždy). Bohužel se kód neobešel bez těchto maker:

// [AsmJit - Types]
namespace AsmJit
{
  typedef char Int8;
  typedef unsigned char UInt8;
  typedef short Int16;
  typedef unsigned short UInt16;
  typedef int Int32;
  typedef unsigned int UInt32;

#if defined(_MSC_VER)
  typedef __int64 Int64;
  typedef unsigned __int64 UInt64;
#else // GCC, other compilers ?
  typedef long long Int64;
  typedef unsigned long long UInt64;
#endif

#if defined(ASMJIT_X86)
  typedef Int32 SysInt;
  typedef UInt32 SysUInt;
#else
  typedef Int64 SysInt;
  typedef UInt64 SysUInt;
#endif
}

#if defined(_MSC_VER)
# define ASMJIT_INT64_C(num) num##i64
# define ASMJIT_UINT64_C(num) num##ui64
#else
# define ASMJIT_INT64_C(num) num##LL
# define ASMJIT_UINT64_C(num) num##ULL
#endif

Taky používáte něco podobného ve vašich programech ?

Použití AsmJit pro X64

Používání AsmJit se nijak neliší od 32bitové verze. Je ale potřeba si uvědomit, že 64bitový režim je trochu jiný. Dřív, než se spálíte, by asi bylo dobré si přečíst nějakou dokumentaci pro přechod na X64. Asi nejdůležitější je vědět, že registry, kde máte ukazatele, už nezačínají písmenem 'e', ale písmenem 'r'. Následuje příklad z původního zápisku, přepsaný pro 64 bitů:

  X86 a;

  // Prolog.
  a.push(rbp);
  a.mov(rbp, rsp);

  // Move 1024 to rax (return value)
  a.mov(rax, 1024);

  // Epilog
  a.mov(rsp, rbp);
  a.pop(rbp);
  a.ret();

Můžete si všimnout, že v takto triviálním příkladu jsou veškeré změny jen přepsání registrů z 'e' na 'r'. Aby bylo snadnější psát assembler více přenositelně, nabízí AsmJit malé rozšíření v podobě nativních registrů. Nativní registr je registr o bitové velikosti 32 nebo 64 bitů v závislosti na současné architektuře. První písmeno takového registru je 'n', tedy nax, nbx, ncx, atd. (to n má být jako nativní, pokud máte návrh na lepší písmenko, tak napište do diskuze). Ukázkový kód by se tedy dal přepsat tak, aby podporoval 32 a 64 bitů současně:

  X86 a;

  // Prolog.
  a.push(nbp);
  a.mov(nbp, nsp);

  // Move 1024 to eax/rax (return value)
  a.mov(nax, 1024);

  // Epilog
  a.mov(nsp, nbp);
  a.pop(nbp);
  a.ret();

Pokračování příště...

Jako pokračování v tomto tématu bych se už nechtěl věnovat implementaci AsmJit, ale použití. Mám přepravený malý kód, který zkompiluje matematický výraz do X86/X64 kódu a pak jej vyhodnotí.

Zdroj

Adresa projektu je http://code.google.com/p/asmjit/. Verze, která podporuje X64 architekturu, je 0.3 nebo SVN.

Zajímavosti v X64

• X86 nebo X64 instrukce musí být zakódovaná maximálně do 15 BYTŮ.
• Číselné konstanty jsou v mnoha případech v instrukcích zakódovány maximálně v 32 bitech, i když je cílová instrukce čistě 64bitová.
• Procesory od AMD jsou schopné přeskočit 15 nop instrukcí v jednom cyklu (Intel nevím)
• Instrukce ENTER a LEAVE, vytvořené pro vstup a návrat z funkce, se nepoužívají, protože jsou pomalé.