BASM for beginners, lesson 1

This series of lessons is dedicated to teach beginners BASM.

Instead of doing a book with chapters about instructions, Calling conventions & code optimization etc., we will be discussing the issues as examples bring them into focus.

The first little example gets us started. It is a simple function in Pascal with multiplies an integer with the constant 2.

function MulInt2(I : Integer) : Integer;

begin
 Result := I * 2;
end;

Let us steal the BASM from the CPU view. I compiled with optimizations turned on.

function MulInt2_BASM(I : Integer) : Integer;

begin
 Result := I * 2;
  {
  add eax,eax
 ret
 }
end;

From this we see that I is transferred to the function in eax and that the result is transferred back to the caller in eax too. This is the conventions for the register calling convention which is the default in Delphi. The actual code is very simple. The times 2 multiplication is obtained by adding I to itself, I+I = 2I. The ret instruction returns execution to the line after the one which called the function.

Let us code the function as a pure asm function.

function MulInt2_BASM2(I : Integer) : Integer;

asm
 //Result := I * 2;
  add eax,eax
 //ret
end;

Observe that the ret function is supplied by the inline assembler.

Let us take a look at the calling code.

This is the Pascal code

procedure TForm1.Button1Click(Sender: TObject);

var

 I, J : Integer;

begin
 I := StrToInt(IEdit.Text);
  J := MulInt2_BASM2(I);
  JEdit.Text := IntToStr(J);
end;

The important line is

J := MulInt2_BASM2(I);

from the cpu view

call  StrToInt

call MulInt2_BASM2

mov esi,eax

After the call to StrToInt from the line before the one which calls our function, I is in eax. (StrToInt is also following the register calling convention). MulInt2_BASM2 is called and returns the result in eax which is copied to esi in the next line.

Optimization issues: Multiplication by 2 can be done in two more ways. Using the mul instruction or shifting left by one. In the IA32 Intel Architecture Software Developer’s Manual Volume 2 – Instruction Set Reference page 536  mul is described. It multiplies the value in  eax by the value held in another register and the result is returned in the register pair edx:eax. A register pair is needed because a multiplication of two 32 bit numbers results in a 64 bit result, just like 9*9=81 - two one digit numbers (can) result in a two digit result.

Because edx gets into use the issue of which registers must be preserved by a function and which can be used freely is raised. This is explained in the Delphi help.

"An asm statement must preserve the EDI, ESI, ESP, EBP, and EBX registers, but can freely modify the EAX, ECX, and EDX registers."

We can conclude that it is no problem that edx is modified by the  mul instruction and our function can also be implemented like this.

function MulInt2_BASM3(I : Integer) : Integer;

asm
 //Result := I * 2;
  mov ecx, 2
  mul ecx
end;

ecx is used also but this is also ok. As long as the result is less than the range of integer it is returned correctly in eax. If I is bigger than half the range of integer, overflow will occur and the result is incorrect.

Implementation with shift

function MulInt2_BASM4(I : Integer) : Integer;

asm
 //Result := I * 2;
  shl eax,1
end;

Timing can reveal which implementation is fastest. We can also consult Intel and AMD documents with latency and throughput tables. On P4 add & mov are 0.5 clock cycles latency and throughput, mul is 14-18 cycles latency and 5 cycles throughput. Shl is 4 clock cycles latency and 1 cycle throughput. The version chosen by Delphi is the most efficient on P4 and this will probably also be the case on Athlon and P3.

Issues not covered: mul versus imul and range checking, other calling conventions, benchmarking, clock count on other processors, clock count for call + ret, location of return address for ret etc. Later lessons will introduce these subjects.