by 'lagprogramming`. The compiler should optimize some comparisons with -1 the same way it optimizes the comparisons with 0 and 1. With other words, if result>-1 should produce a code as efficient as if result>=0, and if result<=-1 should produce a code as efficient as if result<0. It should be trivial for FPC developers to complete these near-zero optimizations. ```pascal function foo(const param:sizeint):sizeint; begin result:=param; if result>-1 then dec(result); if result<1 then inc(result); if result<=-1 then dec(result); if result>=1 then inc(result); if result<0 then dec(result); if result>0 then inc(result); end; ``` The code produced is ``` .section .text.n_unit1_$$_foo$int64$$int64,"ax" .balign 16,0x90 .globl UNIT1_$$_FOO$INT64$$INT64 .hidden UNIT1_$$_FOO$INT64$$INT64 .type UNIT1_$$_FOO$INT64$$INT64,@function UNIT1_$$_FOO$INT64$$INT64: .Lc2: .Ll1: # [unit1.pas] # [33] begin movq %rdi,%rax # Var param located in register rax # Var $result located in register rax # Var param located in register rax .Ll2: # [35] if result>-1 then dec(result); cmpq $-1,%rdi setg %cl movzbl %cl,%ecx subq %rcx,%rax .Ll3: # [36] if result<1 then inc(result); testq %rax,%rax setle %cl movzbl %cl,%ecx addq %rcx,%rax .Ll4: # [37] if result<=-1 then dec(result); cmpq $-1,%rax setle %cl movzbl %cl,%ecx subq %rcx,%rax .Ll5: # [38] if result>=1 then inc(result); testq %rax,%rax setnle %cl movzbl %cl,%ecx addq %rcx,%rax .Ll6: # [39] if result<0 then dec(result); testq %rax,%rax setl %cl movzbl %cl,%ecx subq %rcx,%rax .Ll7: # [40] if result>0 then inc(result); testq %rax,%rax setg %cl movzbl %cl,%ecx addq %rcx,%rax .Lc3: .Ll8: # [41] end; ret .Lc1: .Lt1: .Le0: .size UNIT1_$$_FOO$INT64$$INT64, .Le0 - UNIT1_$$_FOO$INT64$$INT64 .Ll9: ``` I think the compiler should replace the two cmp instructions with test ones. Comparisons with 0 and 1 are ok so it should be trivial to modify the compiler in order to optimize these -1 comparisons. Probably the compiler developer who implemented this kind of optimization forgot about the -1 scenario.