Programme (D) » ASCALM » Was ist CALM?
Was ist CALM? - ASCALM - Crossassembler mit CALM
CALM-Assembler CALM
Was ist CALM ?
CALM steht für Common Assembly Language for Microprocessors, oder
auf Deutsch: allgemeine Assemblersprache für Mikroprozessoren.
CALM ist keine neue Programmiersprache, sondern eine andere,
einheitliche und prozessorunabhängige Schreibweise von
Assemblerbefehlen. Heutzutage ist es so, dass jeder Hersteller für
seinen Mikroprozessor eine eigene Assemblersprache definiert. Auch die
verwendete Terminologie hängt stark vom Mikroprozessor ab. Aber eine
einheitliche Schreibweise von Befehlen, die funktionell gesehen 100%
identisch sind, vermisst man heute noch immer.
CALM nützt nun die Tatsache aus, dass eben viele Befehle - auch auf
den unterschiedlichsten Mikroprozessoren - genau dieselbe Operation
ausführen. Liegt es in solchen Fällen nicht auf der Hand, die gleiche
Schreibweise - unabhängig vom Prozessor - für diese Befehle
festzulegen?
Was definiert CALM ?
CALM definiert eine einheitliche, prozessorunabhängige Syntax für
Befehle und Pseudobefehle. Aufgrund langjähriger Erfahrung und
Erprobung an über 20 Mikroprozessoren hat es sich gezeigt, dass fast
alle Befehle eines Mikroprozessors durch die von CALM definierten
Befehle und deren Schreibweise ausgedrückt werden können.
CALM definiert aber auch eine einheitliche Assemblerterminologie.
Und es wird ein Konzept angeboten, das aufzeigt, wie ein Befehl
zusammengesetzt ist. Der Benutzer versteht, warum ein Befehl in CALM
so und nicht anders geschrieben wird. Ausserdem wird eine einheitliche
Schreibweise für Operationscodes, Adressierungsarten, Adressen- und
Datenangaben, usw. definiert.
CALM propagiert eine einzige Schreibweise der Befehle für alle
(Mikro)prozessoren. Dieses Ziel erfüllt CALM in rund 95% der Befehle
eines Mikroprozessors. Der Rest entfällt auf prozessorspezifische
Eigenheiten, die von einer allgemeinen Assemblersprache nicht
abgedeckt werden können. Aber es ist in vielen Fällen vorteilhaft,
dass sich diese Besonderheiten auch in der Schreibweise unterscheiden.
Welche Vorteile ergeben sich für den Benutzer ?
Eine einheitliche Schreibweise der Befehle und insbesondere der
Adressierungsarten vermittelt ein objektives Bild von der
Leistungsfähigkeit eines Mikroprozessors. Daher sind auch objektive
Vergleiche von Mikroprozessoren möglich.
Erstmalig können sich Programmierer unterschiedlicher
Mikroprozessoren verständigen. Bisher scheiterten sie an der untersten
Stufe, den verschiedenen Schreibweisen.
Prozessorwechsel werden wesentlich vereinfacht, da sich die
Schreibweise der Befehle nicht ändert. Nur die allgemeine Struktur und
einige Besonderheiten des neuen Prozessors müssen erlernt werden.
CALM eignet sich nicht nur für Mikroprozessoren, sondern auch für
Miniprozessoren, Grossrechner und mikroprogrammierte Rechner. CALM ist
in allen Stufen erweiterbar und daher nicht nur auf 8, 16 und 32 Bit
Prozessoren beschränkt.
Und welche Nachteile ?
CALM definiert nur den Softwareteil eines Prozessors. Benötigt man
aber Hardwareinformationen (Ausführungszeit, Befehlscode, Pinbelegung,
elektrische Belastbarkeit, Angaben zu eingebauten Funktionen wie
Timer, DMA-Einheiten, usw.), dann ist die Herstellerdokumentation
unumgänglich. Der Benutzer muss daher zeitweise beide Schreibweisen
der Befehle kennen: die von CALM und die des Herstellers.
Beispiele
Folgende Seite zeigt anhand der Mikroprozessoren 8080, iAPX86 und
68000 die Schreibweise der Befehle in CALM und die des Herstellers.
CALM-Assembler CALM
; 8080: Multiplikation: RESULTAT.16 = MUL1.8 * MUL2.8
; modifiziert: A, B, D, E, H, L, F
MULT: MULT:
MOVE MUL1,A LDA MUL1
MOVE A,E MOV E,A
MOVE #0,D MVI D,0
MOVE MUL2,A LDA MUL2
MOVE #0,HL LXI H,0
MOVE #8,B MVI B,8
SCHLAUFE$: SCHLAUFE:
ADD HL,HL DAD H
RLC A RAL
JUMP,CC WEITER$ JNC WEITER
ADD DE,HL DAD D
WEITER$: WEITER:
DEC B DCR B
JUMP,NE SCHLAUFE$ JNZ SCHLAUFE
MOVE HL,RESULTAT SHLD RESULTAT
RET RET
; iAPX86: übersetzt eine EBCDIC Zeichenfolge in ASCII-Codes (
; beendet). Annahme: ES = DS, [DS] ist gleichbedeutend mit {DS}*16
; modifiziert AL, BX, CX, DI, SI, F
EBCDIC_ASCII: EBCDIC_ASCII: PROC NEAR
MOVE.16 #CONV_TAB,BX MOV BX,OFFSET CONV_TAB
MOVE.16 #EBCDIC_ZEICHEN,SI MOV SI,OFFSET EBCDIC_ZEICHEN
MOVE.16 #ASCII_ZEICHEN,DI MOV DI,OFFSET ASCII_ZEICHEN
MOVE.16 [DS]+ASCII_LAENGE,CX MOV CX,SIZE ASCII_LAENGE
AUTOINC CLD
SCHLAUFE$: SCHLAUFE:
MOVE.8 [DS]+{SI!},AL LODS EBCDIC_ZEICHEN
MOVE.8 [DS]+{BX}+{AL},AL XLAT CONV_TAB
MOVE.8 AL,[ES]+{DI!} STOS ASCII_ZEICHEN
COMP.8 #16'D,AL CMP AL,0DH
LOOP,NE SCHLAUFE LOOPNE SCHLAUFE
RET.16 RET ; EQ: CR gefunden
; 68000: Division: D4 = D5D4 / D3, Rest in D5, CS falls Fehler
DIV64: DIV64
TEST.32 D3 TST.L D3
JUMP,ZS R8^DIV_NULL$ BEQ.S NULL
PUSH.32 D0 MOVE.L D0,-(A7)
MOVE.32 #32-1,D0 MOVEQ #32-1,D0
DIV_SCHLAUFE$: SCHLAUFE
SETX ORI #$10,CCR
RLX.32 D4 ROLX.L D4
RLX.32 D5 ROLX.L D5
JUMP,CS R8^DIV_UEBER$ BCS.S UEBER
SUB.32 D3,D5 SUB.L D3,D5
JUMP,HS R8^DIV_OK$ BCC.S OK
ADD.32 D3,D5 ADD.L D3,D5
TCLR.32 D4:#0 BCLR #0,D4
DIV_OK$: OK
DJ.16,NMO D0,DIV_SCHLAUFE$ DBRA D0,SCHLAUFE
POP.32 D0 MOVE.L (A7)+,D0
CLRC ANDI #$FE,CCR
RET RTS
DIV_UEBER$: UEBER
POP.32 D0 MOVE.L (A7)+,D0
DIV_NULL$: NULL
SETC ORI #$1,CCR
RET RTS
CALM-ASSEMBLER - Produktbeschreibung (PC/MS-DOS, Atari ST, Smaky)
Der CALM-Assembler besteht aus mehreren Programmen und Dateien:
Die Assemblerprogramme
ASCALM: Der eigentliche Assembler. Er funktioniert wie alle anderen
Assembler auch. Einziger Unterschied: Die Programme müssen in der
herstellerunabhängigen Assemblersprache CALM geschrieben werden.
Vorteil: Diese Assemblersprache unterscheidet sich nicht von Prozessor
zu Prozessor. Mit den entsprechenden Modulen wird der Maschinencode
ohne Binder/ Linker für fast alle Mikroprozessoren erzeugt (siehe
Liste). Assemblerleistungen: Marken (32 Zeichen signifikant),
lokale Marken, Ausdrücke mit 32 Bit Genauigkeit, bedingte
Assemblierung (.IF/.ELSE/.ENDIF), bedingte Auflistung
(.LIST/.ENDLIST), Einfügen beliebig grosser Dateien (.INS), aktuelle
Systemzeit und -datum über Konstanten aufrufbar, Einfügen der
Fehlermeldungen (Sprache wählbar) direkt in die Quelldatei,
Querverweislistengenerator, Makros, u.v.m. Makroleistungen: bis zu
acht Parameter sowie eine Datenangabe können bei einem Makroaufruf
übergeben werden. Die Länge eines Parameters ist nur durch die
Zeilenlänge beschränkt. Parameter können vordefiniert werden. Beim
Makroaufruf kann man zwischen vordefinierten und übergebenen Para-
metern unterscheiden. Makros können andere Makros aufrufen (Schachtel-
tiefe: 10). Ausserdem können mit speziellen Funktionen die übergebenen
Parameter analysiert werden (Vergleich, Kopieren, Zeichen testen,
usw.). Somit können leistungsfähige Makros erstellt werden, die bsw.
die Befehle von der Herstellerschreibweise in die CALM-Schreibweise
übersetzen. Maschinencode-Ausgangsformat: MUFOM (siehe unter MUFBIN).
MUFBIN: Wandelt die vom Assembler erzeugten Objektdateien
(MUFOM-Format) in die Formate binär (.BIN/.COM), hex, Intel hex
(.HEX), Motorola S Format (.FRS), PC/MS-DOS (.EXE) und Atari ST
(.TOS/.TTP/.PRG) um.
Debugger für 8086 (DBGCALM, PC/MS-DOS) oder 68000 (DEBUG68, Atari
ST und Smaky). Mit Disassembler (CALM-Schreibweise).
Die Hilfsprogramme
CALMMENU präsentiert ein einfaches Menü.
FORMCALM formatiert (verschönert) eine CALM-Assemblerquelldatei.
LSTTOASM wandelt Auflistungen in Quelldateien um.
PFED ein Programmeditor (mit Makros!).
PROCSET ändert die Vorgabe in *.PRO-Modulen.
SPACETAB ersetzt Leerzeichen durch Tabulatoren.
TABSPACE ersetzt Tabulatoren durch Leerzeichen.
TESTLIST überprüft eine Auflistungsdatei.
Dateien zu einem Prozessor
*.DOK CALM-Befehlsliste für den Prozessor * , z.B. Z80.DOK.
*.PRO das Modul für den Prozessor * , z.B. Z80.PRO.
B*.TXT Beschreibung zum Prozessormodul, z.B. BZ80.TXT.
C*.TXT Befehlsvergleich (Herstellerschreibweise ->
CALM-Schreibweise).
D*.EXE CALM-Disassembler für den Prozessor *, z.B. DZ80.EXE.
I*.TXT Liste von Maschinencodes mit CALM-Schreibweise
(Disassemblierung).
ST*.ASM Befehlsliste in der CALM-Schreibweise (alphabetisch
geordnet).
S_*.ASM Programmbeispiele (oder E*.ASM oder *.ASM).
T*.ASM Testdatei (Liste der Befehle).
xxx_CALM Übersetzer (Herstellerschreibweise -> CALM)
CALM_xxx Übersetzer (CALM -> Herstellerschreibweise)
Hinweis: je nach Prozessor fehlen einige der obigen Dateien.
Bemerkungen zum CALM-Assembler
Objektcode ohne Binder
Der CALM-Assembler erzeugt ohne Binder (Linker) einen Objektcode im
sogenannten MUFOM-Format. Damit erhält der Benützer nach Umwandlung
des MUFOM-Formats in das Binärformat direkt ein lauffähiges Programm.
Dies ist in vielen Fällen ausreichend. Auch benötigt die
Kombination Assembler-Binder, die relokative Programmteile erzeugt und
bindet, oft mehr Zeit als ein Assembler, der jeweils das ganze
Assemblerprogramm assembliert und direkt den Maschinencode erzeugt.
Dazu sollte ein Minimum an leistungsfähiger Hardware vorhanden sein
(z.B. Festplatten und emulierte Laufwerke im Hauptspeicher).
Die Art der Programmierung hängt natürlich von den Anforderungen
ab. Programme für einfache 8-Bit-Mikroprozessoren (6502, 6800, 8080,
Z80) und Mikrocomputer sind relativ klein. Ausserdem basieren diese
Prozessoren auf Betriebssystemen, die das Anwenderprogramm immer an
der gleichen Adresse laden und ausführen.
Bei leistungsfähigeren Mikroprozessoren (6809, iAPX86, 68000,
NS32000) und Betriebssystemen sind die Anforderungen höher: Programme
müssen an beliebiger Speicheradresse ausgeführt werden können und
Programme sind in Programm-, Daten- und Stapelsegmente aufzuspalten.
Beide Anforderungen sind dank leistungsfähigen Adressierungsarten
(relative Adressierung, indirekte Adressierung mit beliebigen
Abstandswerten (Offset)), usw., ohne weiteres möglich.
Beim CALM-Assembler kann der Programmierer die Adressierungsart
frei wählen. Will er positionsunabhängige Programme erzeugen (die an
einer beliebigen Adresse ausgeführt werden können ohne Relokation),
dann darf er nur noch die relative Adressierung verwenden. Auf Daten-
und Stapelsegmente kann nur noch mittels indirekter Adressierung
zugegriffen werden. Lohn dieser Einschränkungen: das generierte
Programm ist direkt ohne umständliche Relokation an beliebiger
Speicherstelle ausführbar.
Man muss auch berücksichtigen, dass sich das Programmierumfeld
gewandelt hat. Niemand adressiert heute in einem Arbeitsspeicher von
einem MByte und mehr Programme und Daten direkt mittels der absoluten
Adressierung. Dieses Konzept erfordert somit eine gewisse Disziplin
vom Programmierer, da einige Adressierungsarten nicht mehr verwendet
dürfen. Wird diese nicht aufgebracht, ist ein Assembler/Binder nötig.
Objektcode im MUFOM-Format
Der CALM-Assembler erzeugt ein Objekt im sogenannten MUFOM-Format.
Dieses Format hat gegenüber den Formaten .HEX (Intel) und S-Format
(Motorola) einige Vorteile: Zusätzlich zu den Eigenschaften der beiden
"Standard"-Formate wie Prüfsumme, Datenadressen, Startadresse,
ASCII-Zeichen, Editierfähigkeit, usw., sind folgende Informationen
vorhanden: Assembler- und Modulversion (Prozessorbeschreibung),
Dateiname, Datierung, verwendeter Prozessortyp (.PROC), Angaben zur
Prozessorarchitektur, sowie sämtliche .TITLE- und .CHAP-Zeigenfolgen
erscheinen ebenfalls in diesem Format. Alle diese Angaben sind
unkodiert (ASCII-Zeichen) und daher mit dem Kommando TYPE lesbar.
Ausserdem ist das MUFOM-Format auch für bindbare Objekte
verwendbar, mit dem Vorteil, dass das MUFOM-Format prozessorunabhängig
ist. Zur Zeit werden nur jene MUFOM-Befehle benutzt, die für nicht
bindbare Objekte notwendig sind.
Prozessordokumentation
Die zur Zeit mitgelieferte CALM-Dokumentation zu einem Prozessor
reicht im Normalfall nicht aus, um einen Prozessor in all seinen
Einzelheiten zu verstehen. Dies gilt insbesondere für Mikroprozessoren
und Mikrocomputer mit eingebauten Funktionen (wie RAM, DMA, E/A). Es
ist daher in fast allen Fällen mindestens die entsprechende
Dokumentation des Herstellers zum betreffenden Prozessor notwendig.
Die CALM-Dokumentation enthält daher auch Vergleichslisten, z.B.
Hersteller- zu CALM-Schreibweise.
CALM-Befehlslisten
CALM-Befehlsliste
In einer CALM-Befehlsliste (engl.: CALM reference card) sind alle
Befehle eines Mikroprozessors in der herstellerunabhängigen
Assemblerschreibweise CALM übersichtlich aufgeführt. Auf wenigen
Seiten erhalten Sie einen umfassenden Überblick.
Nutzen einer CALM-Befehlsliste
CALM-Befehlslisten sind in erster Linie als Hilfe im täglichen
Programmiereinsatz gedacht: Welche Adressierungsarten sind bei AND
erlaubt? Welche Bedingungsbits werden bei COMP verändert? usw.
Aber auch wenn Sie sich nicht für den CALM-Assembler interessieren,
so kann eine CALM-Befehlsliste für Sie doch nützlich sein: Wenn Sie
beispielsweise:
- den eigenen Mikroprozessor durch andere Darstellungsweise
besser kennenlernen wollen
- eine herstellerunabhängige Beschreibung aller Mikroprozessor-
befehle bekommen wollen
- Mikroprozessoren vergleichen und nicht nur auf Hersteller-
angaben angewiesen sein wollen
- einen neuen, besseren Mikroprozessor suchen
- die Leistungsfähigkeit eines Mikroprozessors beurteilen sollen
- sagen sollen, ob ein Mikroprozessor einen bestimmten Befehl/
Operationscode/Adressierungsart/Datentyp besitzt
- CALM zuerst kennenlernen wollen
Aufbau einer CALM-Befehlsliste
Die CALM-Befehlslisten sind alle nach dem gleichen Schema
zusammengestellt. Dies ergibt einerseits ein einheitliches Aussehen
und andererseits sind direkte Vergleiche möglich.
Ausserdem werden unter den CALM-Operationscodes jeweils die
Herstelleroperationscodes angegeben.
Die CALM-Befehlslisten sind in Englisch abgefasst.
Lieferumfang einer CALM-Befehlslistendokumentation
Eine CALM-Befehlslistendokumentation besteht aus:
- CALM-Befehlsliste
- Vergleich Herstellerschreibweise -> CALM-Schreibweise der
Befehle
- Beispiel (in CALM- und Herstellerschreibweise)
- alphabetisch geordnete Liste aller Operationscodes in der CALM
Schreibweise
- alphabetisch geordnete Liste aller Befehlscodes mit den
entsprechenden Befehlen in der CALM-Schreibweise
Beispiel einer CALM-Befehlsliste
Auf den folgenden Seiten ist die CALM-Befehlsliste für den 8080/5
dargestellt.
8080/8085 - 1
8080/8085
CALM REFERENCE CARD
8080/8085 Description
Programming Model
15 8 7 0
-----------------------------------------------------------------
A [ accumulator | N . Z . x . H . 0 . P . v . C ] F
-----------------------------------------------------------------
B [ | ] C
-----------------------------------------------------------------
D [ | ] E
-----------------------------------------------------------------
H [ | ] L
-----------------------------------------------------------------
15 0
-----------------------------------------------------------------
[ stack pointer ] SP
-----------------------------------------------------------------
[ program counter ] PC
-----------------------------------------------------------------
General
Address: 16 bit
Data: 8 bit (8085: data multiplexed with addresses A0-A7)
Abbreviations used
v 16'0, 16'8, 16'10, 16'18, 16'20, 16'28, 16'30, 16'38
r8 A B C D E H L
s8 B C D E H L
r16 BC DE HL SP
i8 {BC} {DE} {HL}
VAL8 8-bit value
VAL16 16-bit value
cc EQ NE CS CC MI PL PO PE
Modifications versus CALM Standard
8 Bit: All transfers are 8 bits wide, except those determined by
register names (1 letter = 8 bit, 2 letters = 16 bits).
Flag v Unspecified 8085 flag: 2's complement overflow (in arithmetic
8-bit and 16-bit operations). 8080: flag is always 1. (U8085)
Flag x Unspecified 8085 flag: sign(op1)*sign(op2) + sign(op1)*sign
(result)(U8085) + sign(op2)*sign(result). For COMP and SUB,
invert sign(op2). 8080: flag is always 0.
Remarks
- flag equalities: EQ=ZS, NE=ZC, CS=LO, CC=HS, MI=NS, PL=NC.
- Reset: IOFF
JUMP 16'0
- Interrupt: IOFF
CALL v
Additional interrupt addresses for 8085: 16'2C, 16'34, 16'3C. (8085)
- NMI: IOFF (8085)
CALL 16'24
- CALM - Intel register names: equal except: F=PSW and 16 bit names.
- CALM - Intel flag names: N=S, Z=Z, H=AC, P=P, C=C.
8080/8085 - 2
Transfer instructions
MOVE #VAL8 |,A []
VAL16 |
r8 |
i8 |
$VAL8 |
A,| VAL16
| r8
| i8
| $n
(MVI LDA MOV LDAX IN STA MOV STAX OUT)
MOVE #VAL8 |,s8 []
s8 |
{HL} |
s8,{HL}
(MVI MOV MOV)
MOVE #VAL16,r16 []
VAL16,HL
HL,VAL16
HL,SP
(LXI LHLD SHLD SPHL)
MOVE HL,{DE} [] (U8085)
{DE},HL
#{HL}+VAL8,DE
#{SP}+VAL8,DE
(SHLX LHLX LDHI LDSI)
PUSH | r16 [], r16 without SP
POP | AF [], [all] if POP AF
(PUSH POP)
SETC [C=1]
(STC)
EX DE,HL []
{SP},HL
(XCHG XTHL)
Arithmetic instructions
ADD | #VAL8 |,A [N,Z,H,P,C]
ADDC | r8 | [N,Z,H,P,C]
SUB | {HL} | [N,Z,H,P,C]
SUBC | [N,Z,H,P,C]
COMP | [N,Z,H,P,C]
(ADI ADD ACI ADC SUI SUB SBI SBB CPI CMP)
ADD r16,HL [C]
(DAD)
SUB BC,HL [N,Z,x,H,P,v,C] (U8085)
(DSUB)
INC | r8 [N,Z,H,P]
DEC | {HL} [N,Z,H,P]
(INR DCR)
INC | r16 []
DEC |
(INX DCX)
8080/8085 - 3
Logical instructions
AND | #VAL8 |,A [N,Z,H,P,C=0]
OR | r8 | [N,Z,H,P,C=0]
XOR | {HL} | [N,Z,H,P,C=0]
(ANA ANI ORA ORI XRA XRI)
NOT A []
NOTC [C]
(CMA CMC)
Shift instructions
RR | A [C = A:#0]
RRC | [C = A:#0]
RL | [C = A:#7]
RLC | [C = A:#7]
(RRC RAR RLC RAL)
ASR HL [C = L:#0] (U8085)
RLC DE [v,C = D:#7] (U8085)
(ARHL RDEL)
Program flow instructions
JUMP,cc | VAL16 []
JUMP |
CALL,cc |
CALL |
JUMP {HL} []
JUMP,XC | VAL16 [] (U8085)
JUMP,XS |
(J- JMP C- CALL PCHL JNX5 JX5)
RST v []
RST,VS 16'40 [] (U8085)
(RST RSTV) one byte call (restart)
RET,cc []
RET []
WAIT []
NOP []
ION []
IOFF []
(R- RET HLT NOP EI DI)
Special instructions
DAA A [N,Z,H,P,C]
(DAA) Decimal Adjust A, only valid after ADD and ADDC
RIM | A [] (8085)
SIM | RIM: read interrupt mask
(RIM SIM) SIM: set interrupt mask
RETEM [all] return from emulation mode (V20)
(RETEM) POP.16 IP; POP.16 CS; POP.16 SF;
MD bit write disable
TRAPNATIVE #VAL8 [MD=1] trap to native mode (8086)(V20)
(CALLN) PUSH.16 SF; PUSH.16 CS; PUSH.16 IP; SET MD;
return with RETI.32
Notes
(8085) only available in 8085.
(U8085) unspecified 8085 flag or operation code.
(V20) only available in V20, V30, V40, and V50 (8080 emulation
mode). (c) Patrick Faeh, June 1985.