Assembler

Den här artikeln behöver källhänvisningar för att kunna verifieras. (2018-12) Åtgärda genom att lägga till pålitliga källor (gärna som fotnoter). Uppgifter utan källhänvisning kan ifrågasättas och tas bort utan att det behöver diskuteras på diskussionssidan.

Assembler eller assemblyspråk är ett sätt att uttrycka maskinkoden för en dators processor på ett sätt som lämpar sig för människor att läsa och skriva. Programmet som översätter assembler till numerisk maskinkod kallas en assemblator.

I maskinkod representeras såväl instruktioner som adresser och övriga konstanta data som mönster av siffror (bitar eller i annan talbas), utan vare sig semantiskt eller strukturellt stöd för minnet. Det är bland annat därför besvärligt att skriva, redigera och felsöka. Assembler möjliggör därför användandet av namngivna data samt att den aktuella maskinens instruktioner skrivs med bokstäver, så kallade mnemotekniska symboler. Detta underlättar högst väsentligt för programmeraren, inte minst för att adresser ofta är relativa (varandra) och därför måste beräknas på nytt vid varje programändring; med en assemblator beräknas symboliska namn snabbt och automatisk, inklusive alla relativa adresser och index för ingående rutiner och datastrukturer.

Assemblatorer har ofta vanliga infixa operatorer för evaluering av (relativa) konstanta uttryck i olika talbaser, inklusive operationer på bitnivå, utförda av assemblatorn (ej processorn man skriver för). Många möjliggör också användandet av makron, något som syntaktisk liknar en funktion i ett ordinärt högnivåspråk men innebär att ett stycke parametriserad assemblerkod (modifierad av aktuell parameter) infogas på varje plats den refereras.

Assembler är alltså ett samlingsnamn för en mängd maskinspecifika språk. Olika processorfamiljer erbjuder olika instruktioner, och olika assemblatorer erbjuder olika syntax för till exempel adressering och makron. Detta gör att det i allmänhet inte går att använda ett assemblerprogram skrivet för en processor på en annan typ av processor. För att göra det möjligt att flytta program mellan olika processortyper används högnivåspråk.

Det program som översätter assemblerkod till maskinkod kallas assemblator och själva översättningsprocessen för assemblering. I denna process försvinner all information om vad instruktioner, data och funktioner kallats i programmet, till stöd för läsbarheten. De ersätts med dels numeriska maskininstruktioner, dels konstanta adresser för platser i minnet där data och instruktioner lagras, samt konstanta data.

Maskinkoden kan via ett disassemblerande program, en disassemblator, återöversättas till assemblerkod. Läsbarheten för ett disassemblerat program blir dock mycket sämre än för assemblerkod, då alla hopp- och minnesadresser endast kan översättas till ett löpnummer, eftersom ursprungskoden inte finns tillgänglig. Det medför att om man vill veta programmets funktion måste man följa koden instruktion för instruktion. För att underlätta, kan en avlusare i stället användas. Dessa har normalt en disassemblator inbyggd samt en trace-funktion som utför en instruktion i taget och mellan dessa visar innehållet i register, stack och arbetsareor. Sedan inväntas användarens respons innan nästa instruktion utförs. Typiska responser är "nästa instruktion", "hoppa till annat ställe", "sätt in 'x' i register/minnesarea", "avbryt", "kör till nästa brytpunkt" samt "kör till slutet".

Några exempel på assemblerkod för olika processortyper.

Exempel på assemblerkod från IBM:s stordatorer (eng: mainframe). Den ursprungliga OS/360-assemblern kom till kring 1960 på IBM:s laboratorium på Lidingö, och torde ha stått modell för de flesta av alla förekommande assemblerspråk därefter.

Inom IBM-världen kallas språket för ASM (eller BAL Basic Assembly Language; det är ofta en generationsfråga). ASM torde vara det vanligaste, kompletterad med beteckning för version, miljö mm, t ex S/390 ASM, ASM-H eller High Level Assembler (HLASM).

Från början skrevs alltid typ "OS/360", där OS står för Operating System, för att skilja från "DOS/360" (Disk Operating System) som innebar att miljön var minidator inte stordator. När minidatorerna fasade ut, började beteckningar typ "S/390" bli allmänna.

Egentligen är det så att när man pratar om hårdvaran, säger man till exempel "S/370"; och pratar man om motsvarande operativsystem, säger man "OS/370".

          AMODE ANY                 Accept both 24 and 31 bit addresses
          RMODE 24                  May also be called by 24 bit address programs
 IEFBR14  CSECT ,                   Control section start, module name and entry point
          USING IEFBR14,15          Establish addressability; reg 15 contains address of entry point
          B     SAVE+72             Skip over PgmId & SaveArea
          DC    AL1(L'PGMID)        Length of name
 PGMID    DC    C'IEFBR14'          The name itself
 SAVE     DC    18F'0'              Own save area; contains registers of calling program
          STM   14,12,12(13)        Save regs of calling program
          ST    13,SAVE+4           Caller's save area addr
          LR    14,13               Retain caller's save area addr
          LA    13,SAVE             Local save area addr
          USING SAVE,13             Switch addressability so we may use reg 15
          ST    13,8(14)            Report own save area addr to calling pgm
 * In case you actually want something done, put it here
          L     13,SAVE+4           Restore save area reg of calling pgm from own save area
          LM    14,12,12(13)        Restore regs of calling pgm
          SR    15,15               Zero register 15 = return code "ok" ==> RC or CC
 *                                  If something went wrong, put another return code in register 15
          BR    14                  Return addr in R14  -- go back to calling pgm
          END   IEFBR14             End assembly and specify default entry point for Linkage Editor / Loader

Det lilla programmet ovan heter IEFBR14 som IBMs klassiska dummy-program (den utför alltså "ingenting"), men är skriven fritt efter hur det troligen ser ut i senaste 31-bitsadress-version, och kan därför knappast bryta IBMs eventuella copyright. Det är alltså inte kopierat från något ställe.

I den allra första versionen innehöll programmet endast raden " BR 14 " (hoppa tillbaka till anropande program), därav namnet, men flera ändringar krävdes för att den skulle anpassas till IBM:s konventioner för hur program ska se ut för att fungera i alla sammanhang och med nyare versioner av hård- och mjukvara.

Det kan tyckas att detta är rätt mycket kod för att faktiskt inte utföra någonting, men mainframe-världen är mer komplex än den är i andra miljöer. Rätt tidigt utvecklades conditional assembly ("villkorlig assembler"), vanligen kallad macroassembler även i andra miljöer. Med detta kunde snarlika grupper av återkommande programrader ges ett namn och med vissa anropsparametrar kan ovanstående kod i ett typiskt program t.ex. reduceras till:

          AMODE ANY                 Accept both 24 and 31 bit addresses
          RMODE 24                  May also be called by 24 bit address programs
 IEFBR14  SAVE
 ...
          RETURN RC=8               ..(at any point of error condition)
 ...
          RETURN
          END   IEFBR14             End of assembly

Här måste makrona SAVE och RETURN vara utförligt fördefinierade antingen i ett särskilt bibliotek eller lokalt i programkoden. IBM har fördefinierat flera hundra standardmacron; varje enskilt företag kan ha minst lika många egna och vissa program har sin grupp som då är särskilt programtypiska.

Följande kod kan köras på ett x86/MS-DOS-system och skriver ut texten "Hello, World!" på skärmen samt avslutar programmet. Programmet använder sig av instruktionen "int" för att anropa operativsystemet för att skriva ut texten på skärmen. Programmet utnyttjar möjligheten att använda symboliska namn; namnet "hello" är ett symboliskt namn för den minnesadress texten "Hello, World!" befinner sig på.

 mov    ah,9
 mov    dx,offset hello
 int 21h
 mov    ah,4Ch
 int 21h
 hello  db 'Hello, World!',0dh,0ah,'$'

Följande är ett utdrag ur programkoden för en enkel processhanterare för multitasking på en MIPS-processor. Koden i exemplet är del av den kod som sparar undan register, pekare och stack (sw-instruktionerna) för den aktiva processen och byter till en annan (lw-instruktionerna).

 lbu    t5 0(t2)
 nop
 addiu    t5 t5 1
 nop
 sb    t5 0(t2)
 sw    t2 4(s1)  ; store gp
 sw    t3 8(s1)  ; store sp
 sw    t4 0(s1)  ; write back pcb1
 sw    s2 0(s0)  ; change curpcb <= pcb2
 lw    k1 0(s2)  ; change CP+4
 lw    gp 4(s2)  ; change gp <= glob2
 lw    sp 8(s2)  ; change sp
 nop
 b restore
 nop

 Adress:     MOVE.L    A0, $FF8240
             ADDI.B    #$D0, D1
             LEA       ($0400,A0), A0
             ROL.W     (A0)
             CMP.W     D1, (A0)
             BNE.S     Adress

• Kompilator
• Interpretator
• Emulator