Assembler routines using Turbo-Pascal

Bild 1 zeigt eine kurze Assembler-Routine, die ihr Argument Word um NBits Bits nach links rotiert und den so erhaltenen Wert im HL-Register als Funktionswert übergibt.


	.z80
	external Word,NBits

rotlft:	ld	HL,(Word)
	ld	A,(NBits)
	and	0F
	or	A
	ret	Z	;kein Rotieren,
			;wenn NBits=0
	ld	B,A
	ld	A,L
	ld	L,0

loop:	sla	A	;MSB im Carry
	rl	H	;     "
	adc	A,L	;Carry wiedereinsetzen
	djnz	loop

	ld	L,A	; Ergebnis in HL
	ret
	end	rotlft

Bild 1. Assembler-Quelle für die Funktion ROTLFT, die ihr integer-Argument Word um NBits nach links rotiert

Word und NBits werden im Assembler-Programm als external deklariert und erscheinen wieder im Inline-Code, der von PMLink erzeugt wurde (Bild 2).


type Bits = 0..15;

function RotLft (Word: integer; NBits: Bits): integer;
begin {Modul ROTLFT}
  InLine (
{0000}    $2A/WORD   /$3A/NBITS  /$E6/$0F/$B7/$C8/$47/$7D/$2E/$00/$CB/$27/
{0010}    $CB/$14/$8D/$10/$F9/$6F/$C9)
end;  {ROTLFT}

Bild 2. Inline-Code zu ROTLFT; der Prozedurkopf wurde von Hand eingegeben

Der Kopf des Unterprogramms muß natürlich von Hand eingesetzt werden; alles weitere ab begin wird von PMLink produziert.

Der Aufbau von PMLink

Das Programm ist in Bild 3 gezeigt.

program PMLink;

  const MaxInd = $1500;  MaxSym = 255;

  type  PrgInd    = 0..MaxInd;    SymInd   = 1..MaxSym;
        SymString = string[6];    FName    = string[14];
        AnyString = string[127];
        Bits      = 0..8;         ItemT    = 0..15;
        FlagT     = (Norm,Rel,Ext,NegOffs,PosOffs);
        ByteRec   = record Low,High: byte end;

  var   Prog:    array[PrgInd] of
                   record Flag:FlagT; Cont: byte end;
        PC:        integer;           OffsPtr: byte;
        SymTab:    array[SymInd] of SymString;
        OffsTab:   array[1..255] of record OPC,Value: integer end;
        Finis,ErrFlag,EoPrg,EoFile: boolean;
        RelFile:   file;              InlFile: text;
        BytePtr:   0..128;            BitCnt:  Bits;
        Buffer:    array[0..127] of byte;
        WB:        ByteRec;           WW: integer absolute WB;
        PrgName:   SymString;
        PrgLen:    integer;           SymPtr:  SymInd;
        AField:    integer;           BField:  string[7];

{$I f:pmlink.bit}    {Bit-Management}
{$I f:pmlink.utl)    {Utilities}

  function RetrWd (N: integer): integer;   { holt ein 16-Bit- }
    var WB: ByteRec;  WW: integer absolute WB; {Wort aus dem     }
  begin                                        {Programmspeicher }
    with WB do
      begin Low := Prog[N].Cont; High := Prog[Succ(N)].Cont end;
    RetrWd := WW
  end;
 procedure FirstPass;

   procedure RelErr (Mess: SymString);
   begin Writeln ('PC = ',Hex(PC), ', Modul: ',PrgName,
                  ',  ',Mess,' relative;   Argument: ',Hex(GetWord)) end;

   procedure SpLErr (Item: ItemT);
   begin Writeln ('PC = ',Hex(PC),', Modul: ',PrgName,', Item: ',Item:2,
                  ', AField: ',Hex(AField),', BField: ',BField) end;

   procedure Store (Bt: byte; F: FlagT);
   begin
     with Prog[PC] do begin Flag := F; Cont := Bt end;
     PC := Succ(PC)
   end;

   procedure GetAField;
   begin
     case GetBits(2) of
       0,1: AField := GetWord;
       2:   RelErr ('Data'); 3: RelErr ('Common')
     end
   end;

   procedure GetBField; var N: 1..6;
   begin
     BField[0] := Chr(GetBits(3));
     for N:=1 to Length(BField) do BField[N] := Chr(GetByte)
   end;
  procedure SetExtern; var Next: integer;
  begin
    SymTab[Symptr] := BField;
    repeat
     Next := RetrWd(AField);
     with Prog[AField] do begin Cont := SymPtr; Flag := Ext end;
     Prog[Succ(AField)].Cont := 0;  {Voreinstellung: kein Offset}
     AField := Next
   until Next=0;
   SymPtr := Succ(SymPtr)
  end;

   procedure SetOffs; var N: byte;
   begin
     for N := 1 to Pred(OffsPtr) do
       Prog[Succ(OffsTab[N].OPC)].Cont := N  {Pointer auf Eintrag }
   end;                                      {in Offset-Tabelle}

   procedure ExtLink; var N: 1..7;
   begin
     BField[0] := Chr(Max(Succ(GetBits(3)),2));
     for N:=1 to Length(BField) do BField[N] := Chr(GetByte)
   end;

   procedure DefOffs (Offset: integer);
   begin
     with OffsTab[OffsPtr] do begin OPC := PC; Value := Offset end;
     OffsPtr := Succ(OffsPtr)
   end;

   procedure StoreWd (Word: integer; F:FlagT);
   begin Store (Lo(Word),F); Store (Hi(Word),F) end;

   procedure SpLink;
     var Item: ItemT;
   begin
     Item := GetBits(4); AField := 0; BField := '';
     if Item in [5..14] then GetAField;
     if Item in [0..3,5..7] then GetBField
     else case Item of
       4:  ExtLink;  {extension link item}
       15: EoFile := true
     end;
     case Item of
       1,3..5,11,12: SpLErr (Item);  {Fehler, keine Verarbeitung}
       2:     PrgName := BField;   6: SetExtern;
       8:     DefOffs (-AField);   9: DefOffs (AField);
       14,15: begin PrgLen := PC; BitCnt := 0; EoPrg := true end
     end                               {Programm- oder File-Ende}
   end;  {SpLink}

 begin  {FirstPass}
   PC := 0; SymPtr := 1; OffsPtr := 1; EoPrg := false;
   repeat
     if GetBits(1)=0 then Store (GetByte,Norm)
     else case GetBits(2) of
       0: SpLink;   {special link item}
       1: StoreWd (GetWord,Rel);
       2: RelErr ('Data'); 3: RelErr ('Common')
     end
   until EoPrg;
   SetOffs
 end;    {FirstPass}


 procedure SecPass;

   procedure Header;
   begin
     Writeln (InlFile); Write (InlFile, '  begin');
     if PrgName<>'' then Write (InlFile,' {Modul ',PrgName,'}');
     Writeln (InlFile); Write (InlFile,'    inline (')
   end;

   procedure WriteLine;

     var EndLine: boolean; ItemCnt: 0..15; LPos: 0..70;

    procedure AdjustLpos; var K,N: 0..7;
    begin
      K := ItemCnt * 4 - LPos - 1; LPos := LPos + K;
      for N:=1 to K do Write (InlFile,' ')
    end;

    procedure WriteItem;

      procedure WriteNorm;
      begin
        Write (InlFile,'$',Copy (Hex(Prog[PC].Cont),3,2));
        PC := Succ(PC); LPos := LPos + 3; Itemcnt := Succ(Itemcnt)
      end;

      procedure WriteRel; var Item: string[5]; Value: integer;
      begin
        Value := RetrWd(PC) - PC; Str(Value,Item);
        if Value>=0 then Item := '+' + Item;
        Write (InlFile,'*',Item);
        PC := Succ(Succ(PC)); ItemCnt := ItemCnt + 2;
        LPos := LPos + Succ(Length(Item))
      end;

      procedure WriteExtern;
        var Name: SymString;
            OP: byte;   Offset: integer;   OffStr: string[6];
      begin
        Name := SymTab[Prog[PC].Cont]; PC := Succ(PC);
        OP := Prog[PC].Cont;           PC := Succ(PC);
        if OP>0 then
        begin Offset := OffsTab[OP].Value; Str (Offset,OffStr);
              if Offset>0 then Name := Name + '+';
              Name := Name + OffStr end;
        Write (InlFile,Name);
        ItemCnt := ItemCnt + 2; LPos := LPos + Length(Name)
      end;

    begin  {WriteItem}
      case Prog[PC].Flag of
        Norm: WriteNorm;   Rel: WriteRel;   Ext: WriteExtern
      end;
    end;   {WriteItem}

  begin  {WriteLine}
    Writeln (InlFile); Write (InlFile,'  {',Hex(PC),'}   ');
    if Odd(PC) then
      begin Write (InlFile,'   '); ItemCnt := 1; LPos := 4 end
      else begin ItemCnt := 0; LPos := 0 end;
    repeat
      WriteItem;
      EoPrg := (PC>=PrgLen); EndLine := (ItemCnt>15); AdjustLPos;
      if not EoPrg then begin Write (InlFile,'/'); LPos := Succ(LPos) end;
    until (EndLine or EoPrg)
  end;   {WriteLine}

  procedure ClosePrg;
  begin
    Writeln (InlFile,')'); Write (InlFile,'  end;');
    if PrgName <> '' then Write (InlFile,'  (',PrgName,')');
    Writeln (InlFile)
  end;

begin  {SecPass}
  PC := 0; EoPrg := false; Header;
  repeat WriteLine until EoPrg;
  ClosePrg
end;   {SecPass}
begin  {PMLink}
  repeat
    OpenFiles; Writeln;
    if not (Finis or ErrFlag) then
    begin
      repeat
        FirstPass; if not EoFile then SecPass
      until EoFile;
      Close (InlFile)
    end
   until Finis
end.

[Listing]

Bild 3. Programmlisting von PMLink. Die in Bild 4 und 5 gezeigten Hilfsroutinen werden über die Include-Option eingelesen

Es benötigt zwei Durchläufe; im ersten (FirstPass) wird die REL-Datei eingelesen und eine interne Darstellung des Programms (Prog) erstellt, die zu jedem Byte Angaben über seine Bedeutung enthält und eine Symbol- und eine Offset-Tabelle umfaßt. Letztere wird benötigt, um Ausdrücke von der Form ld A,(Num+5) verarbeiten zu können (wobei Num als external deklariert wurde). Der entsprechende Inline-Code ($3A/NUM+5/) wird allerdings erst ab Turbo-Pascal-Version 3.0 verarbeitet - bei älteren Versionen sollten also Offsets keine Verwendung finden. Im zweiten Durchlauf wird entsprechend der internen Darstellung der Inline-Code erzeugt und auf die INL-Datei ausgegeben.

Zu PMLink gehören noch die Module PMLINK.UTL (Bild 4),

  procedure Beep; begin Write (#7) end;

  procedure IOErr (Message: AnyString);
  begin ErrFlag := true; Beep; Writeln (Message); Writeln end;

  procedure OpenFiles;
    var   PPos: byte;
          RelName,InlName: FName;
  begin
    BytePtr := 128; BitCnt := 0;
    Finis := false; ErrFlag := false; EoFile := false;
    Writeln; Write ('REL-File: '); Read (RelName);
    if RelName='' then Finis := true
    else begin
      PPos := Pos (RelName,'.');
      if PPos=0 then
        begin PPos := Length(RelName) + 1; RelName := RelName + '.REL' end;
{$I-} Assign (RelFile,RelName); Reset (RelFile);
{$I+} if IOResult>0 then IOErr ('   Kein Rel-File!')
      else begin
        Write (' - Inline-File: '); Readln (InlName); Writeln;
        if InlName='' then InlName := Copy(RelName,1,PPos) + 'INL'
          else if Pos(InlName,'.')=0 then InlName := InlName + '.INL';
{$I-}   Assign (InlFile,InlName); Rewrite (InlFile);
{$I+}   if IOResult>0 then IOErr ('Fehler im Inline-File!')
      end
    end
  end;

    type HexString = String[4];
  function Hex (Number: integer): HexString;
    var N,Intm: integer; IntStr: HexString;
  begin
    Intstr := '0000';
    for N := 4 downto 1 do
    begin
      Intm := (Number and $0F) + $30;
      if Intm > $39 then Intm := Intm + 7;
      IntStr[N] := Chr(Intm); Number := Number shr 4
    end;
    Hex := IntStr
  end;
  function Max (A,B:integer): integer;
  begin if A>=B then Max := A else Max := B end;

[Listing]

Bild 4. Einige von PMLink benötigte Hilfsroutinen, u.a. zur Eingabe der Dateinamen und zur Hexadezimaldarstellung von Zahlen

das einige Hilfsroutinen enthält, und PMLINK.BIT (Bild 5),

[Listing]

Bild 5. Die Routinen zum bitweisen Lesen der REL-Datei

das die Grundlage für ein bitweises Einlesen der REL-Datei schafft. Der von M80 erzeugte Code ist nämlich im Bitstrom organisiert, d.h. die einzelnen Elemente (Items) beginnen und enden nicht an Bytegrenzen. Das jeweils erste (höchstwertige) Bit eines Elements gibt an, ob es sich bei den folgenden acht Bits um ein absolut einzusetzendes Byte handelt. Hat dieses Bit den Wert 1, so entscheiden statt dessen die nächsten zwei Bits über das weitere Schicksal der folgenden Bits usw. (Einzelheiten hierüber findet man im Macro-80 Reference Manual von Microsoft, Anhang D [oder hier]). Durch diesen Aufbau im Bitstrom wird die REL-Datei klein gehalten, und es werden die Diskettenzugriffe beim Lesen minimiert. Wie die Routinen in PMLINK.BIT zeigen, ist bitweises Lesen in Turbo-Pascal recht einfach zu verwirklichen.

Ein umfangreicheres Beispiel

Bild 6 zeigt eine Version der Funktion GetBits in Z80-Assembler.


	.z80
	external NBits,BitCnt,WB,InByte

getbts:	ld	HL,0	;Ergebnis-Register
	ld	A,(NBits)
	ld	C,A	;C := NBits
	ld	A,(BitCnt)
	cp	C
	jr	NC,ok	;BitCnt>=NBits

	ld	B,A	;B := BitCnt
	ld	A,C	;A := NBits
	sub	B	;A : = NBits - BitCnt
	ld	(NBits),A
	ld	A,(WB)
	call	shl	;WB shl BitCnt
	push	HL	;Zwischenergebnis
	call	InByte	;neues Byte in L
	ld	A,(NBits)
	ld	B,A	;B := NBits
	ld	A,8	;
	sub	B	;A := 8 - NBits
	ld	(BitCnt),A
	ld	A,L	;neues  Byte
	pop	HL
	call	shl	;WB shl NBits
	ld	(WB),A
	ret

ok:	ld	B,C	;B := NBits
	sub	B	;A := BitCnt - NBits
	ld	(BitCnt),A
	ld	A,(WB)
	call	shl
	ld	(WB),A
	ret

shl:	sla	A	;MSB in Carry
	rl	L
	djnz	shl
	ret

	end	getbts

Bild 6. Eine Version der Funktion GetBits in Assembler

PMLink kann nun dazu verwendet werden, um sich selbst etwas effektiver zu machen (der Geschwindigkeitsvorteil wirkt sich allerdings nur bei der Verwendung von RAM-Disks aus, da im anderen Fall die Diskettenzugriffe die Arbeitsgeschwindigkeit des Programms bestimmen). Der mit PMLink erzeugte entsprechende Inline-Code ist in Bild 7 gezeigt.


function GetBits (NBits: Bits): byte;
begin {Modul GETBTS}
  inline (
{0000}    $21/$00/$00/$3A/NBITS  /$4F/$3A/BITCNT /$B9/$30/$23/$47/$79/$90/
{0010}    $2/NBITS   /$3A/WB     /$CD/*+40   /$E5/$CD/INBYTE /$3A/NBITS  /
{0020}    $47/$3E/$08/$90/$32/BITCNT /$7D/$E1/$CD/*+21   /$32/WB     /$C9/
{0030}    $41/$90/$32/BITCNT /$3A/WB     /$CD/*+6    /$32/WB     /$C9/$CB/
{0040}    $27/$CB/$15/$10/$FA/$C9)
end; {GETBTS}

Bild 7. Inline-Version von GetBits. Der Aufruf von InByte wird in dieser Form erst ab Turbo-Pascal Version 3.0 verarbeitet

GETBTS zeigt unter anderem, daß es auch möglich ist, Prozeduren und Funktionen, die in Pascal definiert worden sind, aus einer Maschinensprache-Routine aufzurufen - wie hier die Funktion InByte. Allerdings werden solche Aufrufe erst ab Turbo-Pascal-Version 3.0 verarbeitet; ältere Versionen des Compilers brechen mit einer Fehlermeldung ab. Diese Einschränkung kann aber leicht umgangen werden: Man plaziere in diesem Fall unmittelbar vor die aufzurufende Pascal-Routine die Deklaration einer typisierten Byte-Konstante mit dem Wert 0, in unserem Beispiel vor InByte das Statement
const InBtAd: byte = 0,
und setze in der Maschinensprache-Routine den Namen dieser Konstante anstatt des Namens der Pascal-Routine ein (also call InBtAd statt call InByte, mit der entsprechenden external-Deklaration). Bei der Ausführung des call-Befehls trifft nun der Prozessor auf die Speicherzelle, in der das Byte mit dem Wert 0 abgelegt ist; dieser Wert wird als Opcode für NOP interpretiert und übersprungen, wodurch schließlich die gewünschte Prozedur erreicht wird.

Was noch zu beachten ist

Bei der Erstellung des Assembler-Codes ist darauf zu achten, daß sich hieraus sinnvoller Inline-Code erzeugen läßt; das Assemblerprogramm sollte z.B. keine aseg-, dseg-, common- oder .phase-Pseudo-Opcodes enthalten. Ebenso wenig ist es sinnvoll, Symbole als public zu deklarieren, da PMLink keinen Maschinensprache-Linker darstellt, d.h. es ist nicht möglich, vor der Erzeugung des Inline-Codes wie mit L80 verschiedene Assembler-Routinen zusammenzubinden. Allerdings können mehrere Module vor der Bearbeitung mit PMLink mit LIB80 zusammengefaßt werden; die Module erscheinen im Inline-Text durch begin und end eingefaßt und sind durch ihre Namen in Kommentarklammern gekennzeichnet.

Assembler-Routinen in Turbo-Pascal

Ein Programm zur Erzeugung von Inline-Code

Der Aufbau von PMLink

Ein umfangreicheres Beispiel

Was noch zu beachten ist