x86 Assembly/16, 32 och 64 bitar - Wikibooks, öppna böcker för en öppen värld (2023)

x86 montering
snabblänkar:register•flytta•hoppa•Beräkna•logik•ordna om•div.•FPU

När du använder x86-montering är det viktigt att ta hänsyn till skillnaderna mellan arkitekturer som är 16, 32 och 64 bitar. Den här sidan kommer att prata om några av de grundläggande skillnaderna mellan arkitekturer med olika bitbredder.

Register[redigera|redigera källa]

16-bitars[redigera|redigera källa]

Registren som finns på 8086 och alla efterföljande x86-processorer är följande: AX, BX, CX, DX, SP, BP, SI, DI, CS, DS, SS, ES, IP och FLAGS. Dessa är alla 16 bitar breda.

På DOS och upp till 32-bitars Windows kan du köra ett mycket praktiskt program som heter "debug.exe" från ett DOS-skal, vilket är mycket användbart för att lära dig mer om 8086. Om du använder DOSBox eller FreeDOS kan du använda "debug .exe"som tillhandahålls av FreeDOS.

AX, BX, CX, DX

Dessa allmänna register kan också adresseras som 8-bitars register. Så AX = AH (hög 8-bitars) och AL (låg 8-bitars).

JA AV

Dessa register används vanligtvis som förskjutningar till datautrymmet. Som standard är SI offset från DS-datasegmentet, DI är offset från ES extra segmentet, men endera eller båda av dessa kan åsidosättas.

SP

Detta är stackpekaren, förskjuten vanligtvis från stacksegmentet SS. Data skjuts in i stacken för tillfällig lagring och hoppar av stacken när den behövs igen.

BP

Stapelramen, vanligtvis behandlad som en offset från stapelsegmentet SS. Parametrar för subrutiner skjuts vanligtvis in i stacken när subrutinen anropas, och BP sätts till värdet SP när en subrutin startar. BP kan sedan användas för att hitta parametrarna på stacken, oavsett hur mycket stacken används under tiden.

CS, DS, SS, ES

Segmentpekarna. Dessa är förskjutningen i minnet för det aktuella kodsegmentet, datasegmentet, stacksegmentet respektive extrasegmentet.

IP

Instruktionspekaren. Offset från kodsegmentet CS, detta pekar på den instruktion som för närvarande exekveras.

FLAGGOR (F)

Ett antal enbitsflaggor som indikerar (eller ibland ställer in) processorns aktuella status.

32-bitars[redigera|redigera källa]

När chipsen började stödja en 32-bitars databuss breddades registren också till 32 bitar. Namnen för 32-bitarsregistren är helt enkelt 16-bitars namn med ett "E" före.

EAX, EBX, ECX, EDX, ESP, EBP, ESI, EDI

Det här är 32-bitarsversionerna av registren som visas ovan.

EIP

32-bitarsversionen av IP. Använd alltid detta istället för IP på 32-bitars system.

EFLAGS

En utökad version av 16-bitars FLAGS-registret.

64-bitars[redigera|redigera källa]

Namnen på 64-bitarsregistren är desamma som på 32-bitarsregistren, förutom att de börjar med ett "R".

RAX, RBX, RCX, RDX, RSP, RBP, RSI, RDI

Dessa är 64-bitarsversionerna av registren som visas ovan.

VILA I FRID

Detta är den fullständiga 64-bitars instruktionspekaren och bör användas istället för EIP (vilket kommer att vara felaktigt om adressutrymmet är större än 4 GiB, vilket kan hända även med 4 GiB eller mindre RAM).

R8-15

Dessa är nya extra register för 64-bitars. De räknas som om registren ovan är register noll till och med sju, snarare än ett till åtta.

R8–R15 kan nås som 8-bitars, 16-bitars eller 32-bitars register. Med R8 som exempel är namnen som motsvarar dessa bredder R8B, R8W respektive R8D. 64-bitarsversioner av x86 tillåter också att den låga byten av RSP, RBP, RSI, RDI nås direkt. Till exempel kan den låga byten av RSP nås med SPL. Det finns inget sätt att direkt komma åt bitarna 8–15 i dessa register, eftersom AH tillåter AX.

128-bitars, 256-bitars och 512-bitars (SSE/AVX)[redigera|redigera källa]

64-bitars x86 inkluderarSSE2(en förlängning till 32-bitars x86), som tillhandahåller 128-bitars register för specifika instruktioner. De flesta processorer som tillverkats sedan 2011 har även AVX, en ytterligare förlängning som förlänger dessa register till 256 bitar. Vissa har även AVX-512, vilket förlänger dem till 512 bitar och lägger till 16 fler register.

XMM0~7

SSE2 och nyare.

XMM8~15

SSE3 och nyare och AMD (men inte Intel) SSE2.

ÅMM0~15

AVX. Varje YMM-register inkluderar motsvarande XMM-register som sin nedre halva.

ZMM0~15

AVX-512F. Varje ZMM-register inkluderar motsvarande YMM-register som sin nedre halva.

ZMM16~31

AVX-512F. 512-bitars register som inte är adresserbara i smalare lägen om inte AVX-512VL implementeras.

XMM16~31

AVX-512VL. Var och en är den nedre fjärdedelen av motsvarande ZMM-register.

YMM16~31

AVX-512VL. Var och en är den nedre halvan av motsvarande ZMM-register.

Adressminne[redigera|redigera källa]

8086 och 80186[redigera|redigera källa]

Den ursprungliga 8086 hade bara register som var 16 bitar stora, vilket effektivt gjorde det möjligt att lagra ett värde i området [0 - (2)¹⁶- 1)] (eller enklare: den kan adressera upp till 65536 olika byte, eller 64 kibibyte) - men adressbussen (anslutningen till minneskontrollern, som tar emot adresser, laddar sedan innehållet från den givna adressen och returnerar data tillbaka på databussen till CPU) var 20 bitar stora, vilket i praktiken gjorde det möjligt att adressera upp till 1 mebibyte minne. Det betyder att alla register i sig inte var tillräckligt stora för att använda hela bredden på adressbussen, vilket lämnade 4 bitar oanvända, vilket minskade antalet användbara adresser med 16 (1024 KiB / 64 KiB = 16).

Problemet var detta: hur kan ett 20-bitars adressutrymme refereras till av 16-bitarsregistren? För att lösa detta problem kom Intels ingenjörer med segmentregister CS (Code Segment), DS (Data Segment), ES (Extra Segment) och SS (Stack Segment). För att konvertera från 20-bitars adress skulle man först dividera den med 16 och placera kvoten i segmentregistret och resten i offsetregistret. Detta representerades som CS:IP (det betyder att CS är segmentet och IP är offset). På samma sätt, när en adress skrivs SS:SP betyder det att SS är segmentet och SP är offset.

Detta fungerar också på omvänt sätt. Om man istället för att konvertera från, skulle skapa en 20-bitars adress, skulle det göras genom att ta 16-bitarsvärdet av ett segmentregister och lägga det på adressbussen, men skiftas 4 gånger till vänster (och därmed effektivt multiplicera registret med 16), och sedan genom att lägga till offset från ett annat register orörd till värdet på bussen, vilket skapar en fullständig 20-bitars adress.

Exempel[redigera|redigera källa]

Om CS = 258C och IP = 0012₁₆, då kommer CS:IP att peka på en 20-bitars adress som motsvarar "CS × 16 + IP" som kommer att vara

258C x 10₁₆+ 0012₁₆= 258C0 + 0012₁₆= 258D2 (Kom ihåg: 16 decimaler = 10₁₆).

20-bitarsadressen är känd som en absolut (eller linjär) adress och Segment:Offset-representationen (CS:IP) är känd som en segmenterad adress. Denna separation var nödvändig, eftersom registret i sig inte kunde innehålla värden som krävde mer än 16 bitars kodning. När man programmerar i skyddat läge på en 32-bitars eller 64-bitars processor, är registren tillräckligt stora för att fylla adressbussen helt, vilket eliminerar segmenterade adresser - endast linjära/logiska adresser används i allmänhet i detta "platta adresserings"-läge, även om deSegmentet:Offsetarkitektur stöds fortfarande för bakåtkompatibilitet.

Det är viktigt att notera att det inte finns en en-till-en-mappning av fysiska adresser till segmenterade adresser; för varje fysisk adress finns det mer än en möjlig segmenterad adress. Till exempel: överväg de segmenterade representationerna B000:8000 och B200:6000. Utvärderade mappar de båda till fysisk adress B8000.

B000:8000 = B000 × 10₁₆+ 8000₁₆= B0000 + 8000₁₆= B8000, och

B200:6000 = B200 × 10₁₆+ 6000₁₆= B2000 + 6000₁₆= B8000.

Genom att använda ett lämpligt mappningsschema undviker man emellertid detta problem: en sådan karta tillämpar en linjär transformation på de fysiska adresserna för att skapa exakt en segmenterad adress för varje. För att vända översättningen inverteras kartan [f(x)] helt enkelt.

Till exempel, om segmentdelen är lika med den fysiska adressen dividerat med 10₁₆och förskjutningen är lika med resten, kommer endast en segmenterad adress att genereras. (Ingen offset kommer att vara större än 0F₁₆.) Fysisk adress B8000 mappar till (B8000 / 10₁₆):(B8000mod10₁₆) eller B800:0. Denna segmenterade representation ges ett speciellt namn: sådana adresser sägs vara "normaliserade adresser".

CS:IP (Code Segment: Instruction Pointer) representerar 20-bitarsadressen för det fysiska minnet varifrån nästa instruktion för exekvering kommer att hämtas. På samma sätt pekar SS:SP (Stack Segment: Stack Pointer) på en 20-bitars absolut adress som kommer att behandlas som stack top (8086 använder detta för att trycka/poppa värden).

Skyddat läge (80286+)[redigera|redigera källa]

Hur fult detta än kan tyckas, var det i själva verket ett steg mot det skyddade adresseringsschemat som används i senare chips. 80286 hade ett skyddat driftläge, där alla dess 24 adresslinjer var tillgängliga, vilket möjliggjorde adressering av upp till 16 MiB minne. I skyddat läge var CS-, DS-, ES- och SS-registren inte segment utan väljare, som pekade in i en tabell som gav information om blocken av fysiskt minne som programmet då använde. I detta läge används pekarvärdet CS:IP = 0010:2400 enligt följande:

CS-värdet 0010₁₆är en förskjutning i väljartabellen, som pekar på en specifik väljare. Denna väljare skulle ha ett 24-bitarsvärde för att indikera början av ett minnesblock, ett 16-bitarsvärde för att indikera hur långt blocket är, och flaggor för att specificera om blocket kan skrivas, om det för närvarande finns fysiskt i minnet, och annan information. Låt oss säga att minnesblocket som pekas på faktiskt börjar på 24-bitars adressen 164400₁₆, den faktiska adressen som hänvisas till då är 164400₁₆+ 2400₁₆= 166800₁₆. Om väljaren även innehåller information om att blocket är 2400₁₆byte lång, skulle referensen vara till byten omedelbart efter det blocket, vilket skulle orsaka ett undantag: operativsystemet bör inte tillåta ett program att läsa minne som det inte äger. Och om blocket är markerat som skrivskyddat, vilket kodsegmentminne ska vara så att program inte skriver över sig själva, skulle ett försök att skriva till den adressen på samma sätt orsaka ett undantag.

När CS och IP utökades till 32 bitar i 386:an blev detta schema onödigt; med en väljare som pekar på den fysiska adressen 00000000₁₆, kan ett 32-bitars register adressera upp till 4 GiB minne. Men väljare används fortfarande för att skydda minnet från oseriösa program. Om ett program i Windows försöker läsa eller skriva minne som det inte äger, till exempel, kommer det att bryta mot reglerna som ställts in av väljarna, vilket utlöser ett undantag, och Windows kommer att stänga av det med meddelandet "Allmänt skyddsfel".

32-bitars adressering[redigera|redigera källa]

32-bitars adresser kan täcka minne upp till 4 GiB i storlek. Det betyder att vi inte behöver använda offsetadresser i 32-bitars processorer. Istället använder vi det som kallas "Flat adressering"-schemat, där adressen i registret direkt pekar på en fysisk minnesplats. Segmentregistren används för att definiera olika segment, så att program inte försöker exekvera stacksektionen, och de försöker inte utföra stackoperationer på datasektionen av misstag.

A20 Gate Saga[redigera|redigera källa]

Som nämndes tidigare hade 8086-processorn 20 adresslinjer (från A0 till A19), så det totala minnet som kunde adresseras av den var 1 MiB (eller 2 till strömmen 20). Men eftersom det bara hade 16 bitars register kom de fram tillSegmentet:Offsetschema eller annars med ett enda 16-bitars register kunde de omöjligen ha åtkomst till mer än 64 KiB (eller 2 till kraften 16) minne. Så detta gjorde det möjligt för ett program att komma åt hela 1 MiB minne.

Men med detta segmenteringsschema kom också en bieffekt. Inte bara kan din kod referera till hela 1 MiB med detta schema, utan faktiskt lite mer än så. Låt oss se hur ....

Låt oss komma ihåg hur vi konverterar från enSegmentet:Offsetrepresentation till linjär 20-bitars representation.

Konverteringen:

Segmentet:Offset=Segmentet× 16 +Offset.

Nu för att se den maximala mängden minne som kan adresseras, låt oss fylla i bådaSegmentetochOffsettill sina maximala värden och konvertera sedan det värdet till dess 20-bitars absoluta fysiska adress.

Så, maxvärde förSegmentet= FFFF₁₆, ochmaxvärde förOffset= FFFF₁₆.

Låt oss nu konvertera FFFF:FFFF till dess 20-bitars linjära adress, med tanke på 16₁₀representeras som 10 i hexadecimal.

Så vi får, FFFF:FFFF -> FFFF × 10₁₆+ FFFF = FFFF0 (1 MiB - 16 byte) + FFFF (64 KiB) = FFFFF + FFF0 = 1 MiB + FFF0 byte.

• Notera:FFFFF är hexadecimalt och är lika med 1 MiBochFFF0 är lika med 64 KiB minus 16 byte.

Sensmoralen i historien:Från Real-läge kan ett program faktiskt referera till (1 MiB + 64 KiB - 16) byte minne.

Lägg märke till användningen av ordet "referera" och inte "åtkomst". Ett program kan referera till så mycket minne men om det kan komma åt det eller inte beror på antalet adressrader som faktiskt finns. Så med 8086:an var detta definitivt inte möjligt eftersom när program gjorde referenser till 1 MiB plus minne, var adressen som sattes på adressraderna faktiskt mer än 20-bitar, och detta resulterade i att adresserna slogs om.

Till exempel, om en kod hänvisar till 1 MiB, kommer denna att lindas runt och peka på plats 0 i minnet, på samma sätt kommer 1 MiB + 1 att slås runt till adress 1 (eller 0000:0001).

Nu fanns det några superfunny programmerare runt den tiden som manipulerade den här funktionen i sin kod, att adresserna lindades runt och gjorde sin kod lite snabbare och några byte kortare. Genom att använda denna teknik var det möjligt för dem att komma åt 32 KiB av övre minnesområdet (det vill säga 32 KiB som rör 1 MiB-gränsen) och 32 KiB minne av det nedre minnesområdet, utan att faktiskt ladda om deras segmentregister!

Enkel matematik ser du, om iSegmentet:Offsetrepresentation du görSegmentetkonstant, sedan sedanOffsetär ett 16-bitars värde och därför kan du ströva runt i ett minnesområde på 64 KiB (eller 2 till 16). Om du nu får ditt segmentregister att peka på 32 KiB under 1 MiB-märket kan du komma åt 32 KiB uppåt för att röra 1 MiB-gränsen och sedan 32 KiB ytterligare, vilket i slutändan kommer att lindas till botten av de mest 32 KiB.

Nu förbise dessa superfunny programmerare det faktum att processorer med fler adressrader skulle skapas. (Notera: Bill Gates har tillskrivits att säga, "Vem skulle behöva mer än 640 KB minne?", och dessa programmerare tänkte förmodligen på liknande sätt.) 1982, bara två år efter 8086, släppte Intel 80286-processorn med 24 adresslinjer . Även om det var teoretiskt bakåtkompatibelt med äldre 8086-program, eftersom det också stödde Real Mode, fungerade många 8086-program inte korrekt eftersom de var beroende av att adresser utanför gränserna lindades runt till lägre minnessegment. Så för kompatibilitetens skull dirigerade IBM-ingenjörer A20-adresslinjen (8086 hade raderna A0 - A19) genom tangentbordskontrollern och tillhandahöll en mekanism för att aktivera/avaktivera A20-kompatibilitetsläget. Om du nu undrar varför tangentbordskontrollern, är svaret att den hade ett oanvänt stift. Eftersom 80286 skulle ha marknadsförts som fullständig kompatibilitet med 8086 (det var inte ens ute särskilt länge) skulle uppgraderade kunder bli rasande om 80286 inte var bugg-för-bugg-kompatibel så att koden designad för 8086 skulle fungerar lika bra på 80286, men snabbare.