# [fpc-pascal] generated assembler

Vincent Snijders vsnijders at quicknet.nl
Thu Sep 21 13:21:32 CEST 2006

```Hi,

I am looking at some shootout benchmarks and I have the following
question. Look at the following program:

program loop;

{\$mode objfpc}

var
d: array[0..\$FFF] of double;
di: PDouble;
i: integer;
c: double;

begin
c := 125;
i := low(d);
repeat
d[i] := c*c;
inc(i);
until i>high(d);
di := @d[low(d)];
repeat
di^ := c*c;
inc(di);
until  di>@d[high(d)]
end.

I am interested at the way the until clause is generated.

The compiler creates this assembler file:
# [15] d[i] := c*c;
fldl	U_P\$LOOP_C
fmul	%st,%st
fstpl	U_P\$LOOP_D(,%edx,8)
fwait
# [16] inc(i);
incl	%edx
# [17] until i>high(d);
cmpl	\$4095,%edx
jng	.L9
# [18] di := @d[low(d)];
movl	\$U_P\$LOOP_D,%ecx
.balign 4
.L16:
# [20] di^ := c*c;
fldl	U_P\$LOOP_C
fmul	%st,%st
fstpl	(%ecx)
fwait
# [21] inc(di);
# [22] until  di>@d[high(d)]
movl	\$U_P\$LOOP_D+32760,%eax
cmpl	%ecx,%eax
jnb	.L16

Line 17 generates two assembler instructions. Line 22 generates three
assembler instructions. As far as I can see both high(d) and @d[high(d)]
are constants, because d is a global variable.

Is it possible that line 22 will generate 2 assembler instructions in
the future? Or is this a limitation of the i386 assembler? Or do I make
a mistake in my reasoning?

Vincent

```