Obsah
1. Mikrořadičová jádra TriCore: dokončení popisu instrukční sady
2. Seznam všech instrukcí jader TriCore (bez FPU)
3. Základní aritmetické instrukce
5. Aritmetické a logické posuny
6. Instrukce typu Load & Store
9. Skoky do podprogramů a návraty z podprogramů
10. Instrukce pro programové smyčky
12. Instrukce pro práci s bitovými poli
13. Instrukce booleovského procesoru
14. Tříadresové instrukce booleovského procesoru
15. Uložení a obnovení kontextu
1. Mikrořadičová jádra TriCore: dokončení popisu instrukční sady
V dnešním článku dokončíme popis instrukční sady jader TriCore. Připomeňme si z předchozí části, že instrukce zpracovávané jádry TriCore jsou sice v některých ohledech odvozeny od klasických RISCových instrukčních sad, ovšem kvůli zařazení DSP operací, dále popsaných šestnáctibitových instrukcí atd. je ve skutečnosti instrukční sada poměrně komplikovaná (navíc jsou některé instrukce složitější, ty se však neprovádí v hlavním CPU). Všechny instrukce můžeme rozdělit do několika kategorií popř. podkategorií:
- Aritmetické instrukce
- Celočíselné
- DSP (popsané minule)
- SIMD (popsané minule)
- Adresová aritmetika
- Logické instrukce
- Bitové posuny
- Manipulace s jednotlivými bity
- Přenosy dat
- Přenosy dat mezi registry
- Podmíněné přenosy dat (CMOV)
- Load/Store
- Porovnání hodnot či adres
- Skoky
- Podmnožina šestnáctibitových instrukcí (popsané minule)
- Systémové instrukce (začátek rutiny pro obsluhu přerušení, debug režim …)
2. Seznam všech instrukcí jader TriCore (bez FPU)
V tabulce zobrazené pod tímto odstavcem jsou vypsány všechny základní instrukce jader TriCore. I když je počet instrukcí poměrně vysoký, stále se jedná o procesorové jádro s RISCovou architekturou, protože ty nejsložitější instrukce (uložení kontextu, násobení, programové smyčky apod.) jsou prováděny v paralelně k tomu vytvořených modulech a nikoli přímo v hlavním CPU:
| Instrukce | Význam mnemotechnické zkratky |
|---|---|
| ABS | Absolute value |
| ABSDIF | Absolute value of difference |
| ABSDIFS | Absolute value of difference with saturation |
| ABSS | Absolute value with saturation |
| ADD | Add |
| ADDC | Add carry |
| ADDI | Add immediate |
| ADDIH | Add immediate high word |
| ADDS | Add with saturation |
| ADDSC | Add scaled address |
| ADDX | Add and generate carry |
| AND | Logical AND |
| AND.comp | Compare, AND and accumulate |
| AND.logic | Bit and logical accumulate |
| ANDN | Logical AND Not |
| BISR | Begin ISR |
| BMERGE | Merges even/odd |
| BSPLIT | Split in even/odd |
| CACHEA.I | Cache Address Invalidate |
| CACHEA.W | Cache Address Writeback |
| CACHEA.WI | Cache Address Writeback and Invalidate |
| CADD | Conditional ADD |
| CADDN | Conditional ADD Not |
| CALL | Call |
| CALLA | Call absolute |
| CALLI | Call indirect |
| CLO | Count leading ones |
| CLS | Count leading signs |
| CLZ | Count leading zeros |
| CMOV | Conditional move |
| CMOVN | Conditional move Not |
| CSUB | Conditional subtract |
| CSUBN | Conditional subtract Not |
| DEBUG | Debug |
| DEXTR | Double extract |
| DISABLE | Disable interrupt |
| DSYNC | Synchronize data |
| DVADJ | Divide adjust |
| DVINIT | Divide initialization word |
| DVSTEP | Divide step |
| ENABLE | Enable interrupt |
| EQ | Equal |
| EQANY | Multiple compare |
| EQZ | Equal zero address |
| EXTR | Extract bit field |
| GE | Greater than or equal |
| IMASK | Insert mask |
| INS | Insert bit |
| INSERT | Insert |
| INSN | Insert bit Not |
| ISYNC | Synchronize instructions |
| IXMAX | Finds maximum value in signed array |
| IXMAX.U | Finds maximum value in unsigned array |
| IXMIN | Finds minimum value in signed array |
| IXMIN.U | Finds minimum value in unsigned array |
| J | Jump unconditional |
| JA | Jump unconditional absolute |
| JEQ | Jump if equal |
| JGE | Jump if greater than or equal |
| JGEZ | Jump if greater than or equal to zero |
| JGTZ | Jump if greater than zero |
| JI | Jump indirect |
| JL | Jump and link |
| JLA | Jump and link absolute |
| JLEZ | Jump if less than or equal to zero |
| JLI | Jump and link immediate |
| JLT | Jump if less than |
| JLTZ | Jump if less than zero |
| JNE | Jump if not equal |
| JNED | Jump if not equal and decrement |
| JNEI | Jump if not equal and increment |
| JNZ | Jump if not equal to zero |
| JZ | Jump if zero |
| LD | Load |
| LDLCX | Load lower context |
| LDMDST | Load modify store |
| LDUCX | Load upper context |
| LEA | Load Effective address |
| LOOP | Loop |
| LOOPU | Loop unconditional |
| LT | Less than |
| MADD(S) | Multiply-Add (S = with Saturation) |
| MADDM(S).H | Packed Multiply-Add Q Format – Multiprecision |
| MADDR(S).H | Packed Multiply-Add Q Format w/ Rounding |
| MADDR(S).Q | Multiply-Add Q Format with Rounding |
| MADDSU(S).H | Packed Multiply-Add/Sub Q Format |
| MADDSUM(S).H | Packed Multiply-Add/Sub Q Format – Multiprecision |
| MADDSUR(S).H | Packed Multiply-Add/Sub Q Format w/ Rounding |
| MAX | Maximum value |
| MFCR | Move from Core Register |
| MIN | Minimum value |
| MOV | Move |
| MOVH(.A) | Move halfword to address |
| MSUB(S) | Multiply-Subtract (S = with Saturation) |
| MSUBAD(S).H | Packed Multiply-Sub/Add Q Format |
| MSUBADM(S).H | Packed Multiply-Sub/Add Q Format – Multiprecision |
| MSUBADR(S).H | Packed Multiply-Sub/Add Q Format w/ Rounding |
| MSUBM(S).H | Packed Multiply-Subtract Q Format – Multiprecision |
| MSUBR(S).H | Packed Multiply-Subtract Q Format w/ Rounding |
| MSUBR(S).Q | Multiply-Subtract Q Format w/ Rounding |
| MTCR | Move to Core Register |
| MUL(S) | Multiply (S = with Saturation) |
| MUL(S).U | Multiply Unsigned (S = with Saturation) |
| MUL.H | Packed Multiply Q Format |
| MUL.Q | Multiply Q Format |
| MULM.H | Packed Multiply Q Format – Multiprecision |
| MULR.H | Packed Multiply Q Format with Rounding |
| MULR.Q | Multiply Q Format with Rounding |
| NAND | Logical NAND |
| NE | Not equal |
| NEZ.A | Not equal zero address |
| NOP | No operation |
| NOR | Logical NOR |
| NOT | Bitwise complement |
| OR | Logical OR |
| OR.comp | Compare, OR and accumulate |
| OR.logic | Bit OR logical accumulate |
| ORN | Logical OR Not |
| PACK | Translates in floating-point format |
| PARITY | Computes parity |
| RET | Return from call |
| RFE | Return from Exception |
| RSLCX | Restore lower context |
| RSTV | Reset overflow flags |
| RSUB | Reverse subtract |
| RSUBS | Reverse subtract with saturation |
| SAT | Saturate result |
| SEL | Select |
| SELN | Select Not |
| SH | Shift |
| SH.comp | Compare accumulate and shift |
| SH.logic | Bit shift logical accumulate |
| SHA | Arithmetic shift |
| SHAS | Arithmetic shift with saturation |
| ST | Store |
| STLCX | Store lower context |
| STUCX | Store upper context |
| SUB | Subtract |
| SUBC | Subtract with carry |
| SUBS | Subtract signed with saturation |
| SUBX | Subtract extended |
| SVLCX | Save lower context |
| SWAP | Swap |
| SYSCALL | System call |
| TLBDEMAP | Uninstall a mapping in the MMU |
| TLBFLUSH | Flush mappings from MMU |
| TLBMAP | Install a mapping in the MMU |
| TLBPROBE.A | Probe the MMU for a virtual address |
| TRAPSV | Trap on sticky overflow |
| TRAPV | Trap on overflow |
| UNPACK | Translates from floating-point format |
| XNOR | Logical exclusive NOR |
| XOR | Logical exclusive OR |
| XOR.comp | Compare, XOR and accumulate |
3. Základní aritmetické instrukce
Některé základní aritmetické instrukce jsme si již popsali minule, takže si nyní pouze uvedeme jejich souhrn. Povšimněte si, že jsou podporovány jak instrukce s přetečením výsledků (to odpovídá zvykům z jiných architektur), tak i se saturací, což je výhodnější ve chvíli, kdy se zpracovávají různé signály. Programátor si taktéž může zvolit, jestli se má použít carry bit uložený v registru PSW či nikoli. Ve spodní části tabulky můžeme vidět instrukce sloužící pro výpočet absolutní hodnoty, výběr maxima či minima ze dvou operandů a taktéž instrukci pro převod 32bitové hodnoty na hodnotu šestnáctibitovou či osmibitovou se saturací (zachová se znaménko, horních 16 či 24 bitů se vynuluje atd.):
| Instrukce | Stručný popis |
|---|---|
| ADD | součet (bez saturace, s přetečením) |
| ADDC | součet + přičtení bitu carry z PSW |
| ADDX | součet s přetečením, nastavuje se carry bit v PSW |
| ADDS | součet se saturací (signed) |
| ADDS.U | součet se saturací (unsigned) |
| ADDI | součet s konstantou (16 bitů rozšířených na 32 bitů) |
| ADDIH | součet s konstantou (16 bitů posunutých doleva) |
| SUB | rozdíl (bez saturace, s podtečením) |
| SUBC | rozdíl + použití bitu carry z PSW |
| SUBS | rozdíl se saturací |
| SUBX | rozdíl, nastavení carry bitu v PSW |
| RSUB | jako SUB, ale s otočením operandů |
| RSUBS | jako SUBS, ale s otočením operandů |
| ABS | výpočet absolutní hodnoty operandu |
| MIN | výpočet minima |
| MAX | výpočet maxima |
| SAT | saturace při převodu 32bit → 16bit nebo 8bit |
4. Logické instrukce
U většiny běžných mikroprocesorů najdeme poměrně omezenou skupinu logických operací, typicky čtveřici NOT, AND, OR a XOR. U jader TriCore je tomu poněkud jinak, protože zde je sada logických instrukcí rozšířena o instrukce s negací vypočteného výsledku (NAND, NOR, XNOR) a taktéž o instrukce, u nichž je nejdříve negován jeden vstupní operand (ANDN a ORN, tato varianta je u XOR zbytečná):
| Instrukce | Stručný popis |
|---|---|
| NOT | negace bit po bitu |
| AND | logická operace AND (logický součin) |
| OR | logická operace OR (logický součet) |
| XOR | logická operace XOR (logická nonekvivalence) |
| NAND | logická operace NAND (negace AND) |
| NOR | logická operace NOR (negace OR) |
| XNOR | logická operace exclusive NOR (negace XOR) |
| ANDN | logická operace AND (logický součin) s jedním operandem negovaným |
| ORN | logická operace OR (logický součet) s jedním operandem negovaným |
Poznámka: první instrukce implementuje logický unární operátor s jedním vstupním operandem, další instrukce jsou binární, tj. se dvěma vstupními operandy a jedním operandem výstupním.
5. Aritmetické a logické posuny
Skupina základních instrukcí pro posuny je poměrně malá, protože obsahuje jen tři instrukce. Jádra TriCore nemusí rozlišovat speciální instrukce pro posun doleva a doprava, protože samotný posun je představován číslem se znaménkem. Ovšem, na rozdíl od mnoha jiných platforem, je k dispozici posun doleva se saturací výsledku, tj. bez přetečení:
| Instrukce | Stručný popis |
|---|---|
| SH | logický posun doprava či doleva |
| SHA | aritmetický posun doprava či doleva |
| SHAS | dtto, ale při posunu doleva se navíc výsledek saturuje (nepřeteče) |
Poznámka: aritmetický posun doleva je shodný s logickým posunem.
6. Instrukce typu Load & Store
Instrukce typu Load & Store existují v několika variantách podle toho, zda se přenáší operandy o velikosti bajtu, 16bitového slova či 32bitového slova a taktéž podle způsobu uložení – adresový či datový registr. Všechny možnosti jsou vypsány v následující tabulce:
| Instrukce | Stručný popis |
|---|---|
| LD.W | načtení hodnoty z paměti do 32bitového datového registru |
| LD.A | načtení hodnoty z paměti do 32bitového adresového registru |
| LD.B | načtení bajtu do pracovního registru se znaménkovým rozšířením |
| LD.BU | načtení bajtu do pracovního registru, horních 24 bitů se vynuluje |
| LD.H | načtení 16bitového slova do pracovního registru se znaménkovým rozšířením |
| LD.HU | načtení 16bitového slova do pracovního registru, horní polovina se vynuluje |
| LD.Q | načtení 16bitového slova do horní poloviny pracovního registru, spodní polovina se vynuluje |
| LD.D | načtení 64bitové hodnoty z paměti do dvou 32bitových datových registrů |
| LD.DA | načtení 64bitové hodnoty z paměti do dvou 32bitových adresových registrů |
| ST.W | uložení datového registru do paměti |
| ST.A | uložení adresového registru do paměti |
| ST.B | uložení spodních osmi bitů registru do paměti |
| ST.H | uložení spodních 16 bitů registru do paměti |
| ST.Q | uložení horních 16 bitů registru do paměti |
| ST.D | uložení registrového páru (datové registry) |
| ST.DA | uložení registrového páru (adresové registry) |
7. Nepodmíněné skoky
Nepodmíněné skoky existují ve čtyřech variantách. Základní instrukce nazvaná jednoduše J (jump) obsahuje buď 24bitový či pouze osmibitový offset, který je po vynásobení dvěma (instrukce totiž vždy leží na sudých adresách) přičten k aktuální hodnotě registru PC (programový čítač, program counter). Varianta instrukce J s osmibitovým offsetem má šířku jen 16bitů (obdoba „Thumb“ u procesorů ARM). Instrukce JI (jump indirect) skočí na adresu uloženou ve vybraném adresním registru (nejnižší bit je ignorován, protože musí být nulový) a konečně instrukce JA (jump absolute) použije absolutní 24bitovou adresu, kterou vynásobí dvěma a navíc horní čtyři bity posune na indexy 31..28 (za nimi je sedm nulových bitů, což poněkud omezuje cíl skoku):
| Instrukce | Stručný popis |
|---|---|
| J | relativní skok, offset je 24bitový (vynásobený dvěma) |
| J | varianta předchozí instrukce, offset je osmibitový (vynásobený dvěma) |
| JI | skok na adresu uloženou ve vybraném adresovém registru |
| JA | absolutní skok, adresa je 24bitová |
8. Podmíněné skoky
Instrukce podmíněných skoků jsou rozděleny do několika skupin. V první skupině jsou skoky, v nichž se porovnává obsah operandu s osmibitovou konstantou, která je znaménkově či beznaménkově rozšířena na 32bitové číslo. Relativní adresa skoku má šířku 15 bitů:
| Instrukce | Stručný popis |
|---|---|
| JEQ | skok při rovnosti |
| JNE | skok při nerovnosti |
| JLT | skok za podmínky < |
| JLT.U | skok za podmínky < (unsigned) |
| JGE | skok za podmínky ≥ |
| JGE.U | skok za podmínky ≥ (unsigned) |
Další instrukce jsou šestnáctibitové (tj. obdoba Thumb instrukcí u ARMu). Tyto instrukce pracují s implicitním datovým registrem D15 (viz předchozí část seriálu), který je buď porovnáván s nulou nebo se čtyřbitovou konstantou znaménkově rozšířenou na 32 bitů. U prvních dvou instrukcí je relativní adresa osmibitová, u dalších instrukcí jen čtyřbitová, protože další čtyři bity jsou použity pro již zmíněnou konstantu:
| Instrukce | Stručný popis |
|---|---|
| JZ | skok když D15==0 |
| JNZ | skok když D15≠0 |
| JEQ | skok když D15=konstanta |
| JNE | skok když D15≠konstanta |
Třetí skupina podmíněných skoků je taktéž zakódována do šestnácti bitů. Může se zde použít libovolný pracovní registr, ovšem relativní adresa skoku je jen čtyřbitová (ze stejného důvodu, jaký byl naznačen v předchozím odstavci):
| Instrukce | Stručný popis |
|---|---|
| JZ | skok když Dx==0 |
| JNZ | skok když Dx≠0 |
| JLTZ | skok když Dx<0 |
| JLEZ | skok když Dx≤0 |
| JGTZ | skok když Dx>0 |
| JGEZ | skok když Dx≥0 |
Poslední skupina podmíněných skoků pracuje s adresovými registry – vybraný registr je buď porovnán s konstantou nebo s nulou:
| Instrukce | Stručný popis |
|---|---|
| JEQ.A | skok když Ax==konstanta |
| JNE.A | skok když Ax≠konstanta |
| JZ.A | skok když Ax==0 |
| JNZ.A | skok když Ax≠0 |
9. Skoky do podprogramů a návraty z podprogramů
Pro volání podprogramů se používá hned několik typů instrukcí. V první řadě se jedná o instrukce typu JL (jump and link), které odpovídají klasickým nepodmíněným skokům, ovšem navíc se návratová adresa ukládá do link registru A11. Dále zde nalezneme instrukce CALL, které navíc uloží celý „horní kontext“ (upper context) do oblasti paměti nazvané CSA (Context Save Area). Opakem je instrukce RET, která obnoví „horní kontext“ a nahradí PC za hodnotu uloženou v registru A11:
| Instrukce | Stručný popis |
|---|---|
| JL | obdoba instrukce J, ovšem návratová adresa se uloží do registru A11 (RA) |
| JLA | obdoba instrukce JA, ovšem návratová adresa se uloží do registru A11 (RA) |
| JLI | obdoba instrukce JI, ovšem návratová adresa se uloží do registru A11 (RA) |
| CALL | jako JL, ovšem navíc uloží „horní kontext“ do CSA |
| CALLA | jako JLA, ovšem navíc uloží „horní kontext“ do CSA |
| CALLI | jako JLI, ovšem navíc uloží „horní kontext“ do CSA |
| RET | návrat z podprogramu, obnoví horní kontext z CSA |
Poznámka: do „horního kontextu“ patří pracovní registry D8 až D15 i adresové registry A10 až A15.
10. Instrukce pro programové smyčky
Pro efektivní implementaci programových smyček existují čtyři instrukce. První dvě instrukce odpovídají podmíněnému skoku JNE, ovšem testovaný registr se nezávisle na splnění či nesplnění podmínky zvýší či sníží o jedničku, což umožňuje implementaci klasických počítaných programových smyček. Další instrukce LOOP je velmi užitečná, protože je prováděna ve vlastní jednotce nezávisle na ALU a proto každá další iterace probíhá v nulovém počtu cyklů (z pohledu programátora). Tato instrukce jako počitadlo používá adresový registr, což je výhodné při implementaci různých filtrů, které stejně musí operandy načítat a ukládat do polí. Poslední instrukce LOOPU provádí nepodmíněný skok, ovšem opět ve specializované jednotce (za „nula“ cyklů). Tato instrukce ukončuje smyčku typu while:
| Instrukce | Stručný popis |
|---|---|
| JNEI | odpovídá instrukci JNE, ovšem první registr je zvýšen o jedničku (nezávisle na splnění či nesplnění podmínky) |
| JNED | odpovídá instrukci JNE, ovšem první registr je snížen o jedničku (nezávisle na splnění či nesplnění podmínky) |
| LOOP | hardwarově optimalizovaná počítaná programová smyčka |
| LOOPU | hardwarově optimalizovaný skok na zadanou adresu |
Následující příklad ukazuje implementaci počítané programové smyčky, v níž se ve funkci počitadla používá registr D10. Smyčka proběhne s hodnotou počitadla 1 až 100 (to proto, že se hodnota počitadla zvýší PO vyhodnocení podmínky skoku):
lea d10, 1
loopA: ...
...
...
jnei d10, 100, loopA
Následuje příklad smyčky, která po první iteraci nebude v praxi vyžadovat žádné další strojové cykly, neboť vyhodnocení konce smyčky bude provedeno paralelně s jejím tělem. Počitadlo je umístěno v adresovém registru A10:
mova a10, 99
loopB: ...
...
...
loop a10, loopB
11. Instrukce s podmínkou
Již minule jsme se zmínili o instrukcích nazvaných SEL a SELN pro podmíněný výběr výsledku, ovšem v instrukční sadě jader TriCore nalezneme i další instrukce, v nichž se provádí rozhodování na základě nějaké podmínky. Kromě podmíněných skoků se jedná o instrukce, které testují nulovost či nenulovost jednoho z pracovních registrů a na tomto základě potom provedou nějakou operaci. Instrukce CMOV a CMOVN provede MOV (přenos dat) pokud je testovaný registr nulový či naopak nenulový. Další čtyři instrukce jsou složitější, protože mají čtyři operandy – testovaný registr, dva registry zdrojové a registr cílový. Podívejme se na tabulku:
| Instrukce | Stručný popis |
|---|---|
| CMOV | pokud je první operand nenulový, přenes zdrojový registr do registru cílového |
| CMOVN | pokud je první operand nulový, přenes zdrojový registr do registru cílového |
| CADD | pokud je první operand nenulový, vypočti součet, jinak do cílového registru ulož první zdrojový registr |
| CADDN | pokud je první operand nulový, vypočti součet, jinak do cílového registru ulož první zdrojový registr |
| CSUB | pokud je první operand nenulový, vypočti rozdíl, jinak do cílového registru ulož první zdrojový registr |
| CSUBN | pokud je první operand nulový, vypočti rozdíl, jinak do cílového registru ulož první zdrojový registr |
Poznámka: instrukce CMOV a CMOVN implementují „polovinu funkcionality“ instrukcí SEL a SELN.
12. Instrukce pro práci s bitovými poli
Dosti neobvyklé jsou instrukce určené pro práci s bitovými poli. Tyto instrukce obsahují zdrojový operand, kterým je 32bitový registr a taktéž dvojici hodnot pos a width. Tato dvojice určuje bitové pole (bity pos+width až pos) ze zdrojového registru, které se přenesou do registru cílového do jeho spodní části. Přitom může či nemusí dojít ke znaménkovému rozšíření. Poslední instrukce je zvláštní tím, že zdrojem není jeden 32bitový registr, ale 64bitový registrový pár:
| Instrukce | Stručný popis |
|---|---|
| EXTR | ze zdrojového registru přečte bity n až m |
| EXTR.U | dtto, ale neprovádí se znaménkové rozšíření |
| DEXTR | jako EXTR, je zdrojem jsou dva registry tvořící 64bitové pole |
13. Instrukce booleovského procesoru
Logické instrukce popsané ve čtvrté kapitole existují i v „bitové“ variantě počítající s vybranými bity vstupních operandů. U každého vstupního operandu (registru) lze zvolit odlišný index bitu vstupujícího do operace, tedy například D10.31 a D9.0. Výsledek se vždy ukládá do nejnižšího bitu výstupního registru, zbylých 31 bitů je vynulováno:
| Instrukce | Stručný popis |
|---|---|
| AND.T | logická operace AND (logický součin) |
| OR.T | logická operace OR (logický součet) |
| XOR.T | logická operace XOR (logická nonekvivalence) |
| NAND.T | logická operace NAND (negace AND) |
| NOR.T | logická operace NOR (negace OR) |
| XNOR.T | logická operace exclusive NOR (negace XOR) |
| ANDN.T | logická operace AND (logický součin) s jedním operandem negovaným |
| ORN.T | logická operace OR (logický součet) s jedním operandem negovaným |
14. Tříadresové instrukce booleovského procesoru
V instrukční sadě jader TriCore najdeme i booleovské instrukce se třemi vstupními registry (jeden z těchto registrů je současně i cílovým registrem). Tyto instrukce provádí dvojici logických operací, přičemž první operace je provedena naprosto stejným způsobem, jaký byl popsán v předchozí kapitole, tj. vybrané bity ze vstupních registrů tvoří vstupní operandy. Ovšem druhá část je odlišná, neboť se mezivýsledek z této operace neuloží přímo do nejnižšího bitu výstupního registru, ale naopak se provede druhá operace (jen AND či OR) mezi nejnižším bitem výstupního registru a mezivýsledkem:
| Instrukce | Stručný popis |
|---|---|
| AND.AND.T | odpovídá instrukci AND.T, ovšem posléze se provede AND mezivýsledku a nejnižšího bitu cílového registru |
| AND.ANDN.T | odpovídá instrukci ANDN.T, ovšem posléze se provede AND mezivýsledku a nejnižšího bitu cílového registru |
| AND.NOR.T | odpovídá instrukci NOR.T, ovšem posléze se provede AND mezivýsledku a nejnižšího bitu cílového registru |
| AND.OR.T | odpovídá instrukci OR.T, ovšem posléze se provede AND mezivýsledku a nejnižšího bitu cílového registru |
| OR.AND.T | odpovídá instrukci AND.T, ovšem posléze se provede OR mezivýsledku a nejnižšího bitu cílového registru |
| OR.ANDN.T | odpovídá instrukci ANDN.T, ovšem posléze se provede OR mezivýsledku a nejnižšího bitu cílového registru |
| OR.NOR.T | odpovídá instrukci NOR.T, ovšem posléze se provede OR mezivýsledku a nejnižšího bitu cílového registru |
| OR.OR.T | odpovídá instrukci OR.T, ovšem posléze se provede OR mezivýsledku a nejnižšího bitu cílového registru |
15. Uložení a obnovení kontextu
Poslední instrukce, o nichž se dnes zmíníme, slouží pro uložení a obnovení kontextu, tj. vybrané skupiny registrů. Kontext se ukládá do k tomu určené oblasti operační paměti CSA (první dvě instrukce) nebo od určené adresy. Do „horního kontextu“ patří pracovní registry D8 až D15 i adresové registry A10 až A15, do „kontextu spodního“ pak pracovní registry D0 až D7 a adresové registry A2 až A7:
| Instrukce | Stručný popis |
|---|---|
| SVLCX | uložení spodního kontextu do CSA |
| RSLCX | obnovení spodního kontextu z CSA |
| STLCX | uložení spodního kontextu |
| STUCX | uložení horního kontextu |
| LDLCX | načtení spodního kontextu |
| LDUCX | načtení horního kontextu |
16. Odkazy na Internetu
- Q (number format)
https://en.wikipedia.org/wiki/Q_%28number_format%29 - TriCore Architecture & Core
http://www.infineon.com/cms/en/product/microcontroller/32-bit-tricore-tm-microcontroller/tricore-tm-architecture-and-core/channel.html?channel=ff80808112ab681d0112ab6b73d40837 - TriCoreTM V1.6 Instruction Set: 32-bit Unified Processor Core
http://www.infineon.com/dgdl/tc_v131_instructionset_v138.pdf?fileId=db3a304412b407950112b409b6dd0352 - TriCore v2.2 C Compiler, Assembler, Linker Reference Manual
http://tasking.com/support/tricore/tc_reference_guide_v2.2.pdf - Infineon TriCore (Wikipedia)
https://en.wikipedia.org/wiki/Infineon_TriCore - C166®S V2 Architecture & Core
http://www.infineon.com/cms/en/product/microcontroller/16-bit-c166-microcontroller/c166-s-v2-architecture-and-core/channel.html?channel=db3a304312bef5660112c3011c7d01ae - Memory segmentation
https://en.wikipedia.org/wiki/Memory_segmentation - Bus mastering
https://en.wikipedia.org/wiki/Bus_mastering - ST10 16-bit MCUs
http://www.st.com/en/microcontrollers/st10–16-bit-mcus.html?querycriteria=productId=LN1111 - XC800 family
https://en.wikipedia.org/wiki/XC800_family - C166 (stránky společnosti Infineon)
https://www.infineon.com/cms/en/product/microcontroller/16-bit-c166-microcontroller/channel.html?channel=ff80808112ab681d0112ab6b2eaf0759#ispnTab3 - C166 Family
https://en.wikipedia.org/wiki/C166_family - Permanent Magnet Synchronous Motor
https://en.wikipedia.org/wiki/Synchronous_motor#Permanent_magnet_motors - Implementing field oriented control of a brushless DC motor
http://www.eetimes.com/document.asp?doc_id=1279321 - Vector control (motor)
https://en.wikipedia.org/wiki/Vector_control_(motor) - Motorola DSP56k
https://www.rockbox.org/wiki/MotorolaDSP56k - Motorola 56000 (Wikipedia)
http://en.wikipedia.org/wiki/Motorola_56000 - Using the Motorola DSP56002EVM for Amateur Radio DSP Projects
http://www.johanforrer.net/EVM/article.html - The Atari Falcon030 „Personal Integrated Media System“
http://www.atarimuseum.com/computers/16bits/falcon030.html - Turtle Beach Corporation (stránky společnosti)
http://www.turtlebeach.com/ - Turtle Beach Corporation (Wikipedia)
https://en.wikipedia.org/wiki/Turtle_Beach_Corporation - Atari Falcon 030 DSP 3D engine test
http://www.digiti.info/video/WHQwMjNRaExfLWs=/atari_falcon030_dsp_3d_engine_test - Atari Falcon030 (německy)
http://www.maedicke.de/atari/hardware/falcon.htm - Old-computers.com: Atari Falcon030
http://www.old-computers.com/museum/computer.asp?c=125&st=1 - Atari Falcon030 (Wikipedia)
http://en.wikipedia.org/wiki/Atari_Falcon - Past and current projects (including Falcon stuff)
http://os.inf.tu-dresden.de/~nf2/projects/projects.html - Atari Falcon 030: The Case For The Defence
http://www.soundonsound.com/sos/1994_articles/sep94/atarifalcon.html - DaVinci processor family
http://www.ti.com/general/docs/datasheetdiagram.tsp?genericPartNumber=TMS320DM365&diagramId=64193 - Texas Instruments DaVinci
https://en.wikipedia.org/wiki/Texas_Instruments_DaVinci - TMS320DM6446 (DaVinci)
http://www.ti.com/product/tms320dm6446 - Digital Media Video Processors (TI)
http://www.ti.com/lsds/ti/processors/dsp/media_processors/davinci/products.page# - TI Wiki
http://processors.wiki.ti.com/index.php/Main_Page - C5000 ultra-low-power DSP
http://www.ti.com/lsds/ti/processors/dsp/c5000_dsp/overview.page - OMAP (Wikipedia)
https://en.wikipedia.org/wiki/OMAP - OMAP – TI Wiki
http://processors.wiki.ti.com/index.php/OMAP - Why OMAP can't compete in smartphones
http://www.eetimes.com/author.asp?section_id=40&doc_id=1286602 - Applications Processors – The Heart of the Smartphone
http://www.engineering.com/ElectronicsDesign/ElectronicsDesignArticles/ArticleID/5791/Applications-Processors-The-Heart-of-the-Smartphone.aspx - TI cuts 1,700 jobs in OMAP shift
http://www.eetimes.com/document.asp?doc_id=1262782 - VLIW: Very Long Instruction Word: Texas Instruments TMS320C6×
http://www.ecs.umass.edu/ece/koren/architecture/VLIW/2/ti1.html - An Introduction To Very-Long Instruction Word (VLIW) Computer Architecture
Philips Semiconductors - VLIW Architectures for DSP: A Two-Part Lecture (PDF, slajdy)
http://www.bdti.com/MyBDTI/pubs/vliw_icspat99.pdf - Very long instruction word (Wikipedia)
https://en.wikipedia.org/wiki/Very_long_instruction_word - A VLIW Approach to Architecture, Compilers and Tools
http://www.vliw.org/book/ - VEX Toolchain (VEX = VLIW Example)
http://www.hpl.hp.com/downloads/vex/ - Elbrus (computer)
https://en.wikipedia.org/wiki/Elbrus_%28computer%29 - Super Harvard Architecture Single-Chip Computer
https://en.wikipedia.org/wiki/Super_Harvard_Architecture_Single-Chip_Computer - Digital Signal Processors (stránky TI)
http://www.ti.com/lsds/ti/processors/dsp/overview.page - C674× Low Power DSP (stránky TI)
http://www.ti.com/lsds/ti/processors/dsp/c6000_dsp/c674×/overview.page - TMS320C30 (stránky TI)
http://www.ti.com/product/tms320c30 - TMS320C6722B
http://www.ti.com/product/tms320c6722b/description - Introduction to DSP
http://www.ti.com/lit/wp/spry281/spry281.pdf - The Evolution of TMS (Family of DSPs)
http://www.slideshare.net/moto_modx/theevo1 - Datasheet k TMS32010
http://www.datasheetarchive.com/dlmain/49326c32a52050140abffe6f0ac4894aa09889/M/TMS32010 - 1979: Single Chip Digital Signal Processor Introduced
http://www.computerhistory.org/siliconengine/single-chip-digital-signal-processor-introduced/ - The TMS32010. The DSP chip that changed the destiny of a semiconductor giant
http://www.tihaa.org/historian/TMS32010–12.pdf - Texas Instruments TMS320 (Wikipedia)
https://en.wikipedia.org/wiki/Texas_Instruments_TMS320 - Great Microprocessors of the Past and Present: Part IX: Signetics 8×300, Early cambrian DSP ancestor (1978):
http://www.cpushack.com/CPU/cpu2.html#Sec2Part9 - Great Microprocessors of the Past and Present (V 13.4.0)
http://jbayko.sasktelwebsite.net/cpu.html - Introduction to DSP – DSP processors:
http://www.bores.com/courses/intro/chips/index.htm - The Scientist and Engineer's Guide to Digital Signal Processing:
http://www.dspguide.com/ - Digital signal processor (Wikipedia EN)
http://en.wikipedia.org/wiki/Digital_signal_processor - Digitální signálový procesor (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Digitální_signálový_procesor - Digital Signal Processing FAQs
http://dspguru.com/dsp/faqs - Reprezentace numerických hodnot ve formátech FX a FP
http://www.root.cz/clanky/fixed-point-arithmetic/ - IEEE 754 a její příbuzenstvo: FP formáty
http://www.root.cz/clanky/norma-ieee-754-a-pribuzni-formaty-plovouci-radove-tecky/ - Čtyři základní způsoby uložení čísel pomocí FX formátů
http://www.root.cz/clanky/binarni-reprezentace-numerickych-hodnot-v-fx-formatu/ - Základní aritmetické operace prováděné v FX formátu
http://www.root.cz/clanky/zakladni-aritmeticke-operace-provadene-ve-formatu-fx/ - Aritmetické operace s hodnotami uloženými ve formátu FP
http://www.root.cz/clanky/aritmeticke-operace-s-hodnotami-ve-formatu-plovouci-radove-carky/ - FIR Filter FAQ
http://dspguru.com/dsp/faqs/fir - Finite impulse response (Wikipedia)
http://en.wikipedia.org/wiki/Finite_impulse_response - DSPRelated
http://www.dsprelated.com/ - Addressing mode (Wikipedia)
https://en.wikipedia.org/wiki/Addressing_mode - Orthogonal instruction set
https://en.wikipedia.org/wiki/Orthogonal_instruction_set - TI 16-bit and 32-bit microcontrollers
http://www.ti.com/lsds/ti/microcontrollers16-bit32-bit/overview.page - TMS 32010 Assembly Language Programmer's Guide (kniha na Amazonu)
https://www.amazon.com/32010-Assembly-Language-Programmers-Guide/dp/0904047423 - COSC2425: PC Architecture and Machine Language, PC Assembly Language
http://www.austincc.edu/rblack/courses/COSC2425/index.html
ČLÁNKY DO MAILU