+ Removed HASCOMPILERPROC define

git-svn-id: trunk@265 -

rtl/arm/int64p.inc

@@ -14,7 +14,7 @@
  **********************************************************************}
 
 {$define FPC_SYSTEM_HAS_MUL_QWORD}
-function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;assembler;[public,alias: 'FPC_MUL_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;assembler;[public,alias: 'FPC_MUL_QWORD']; compilerproc;
 asm
   mov r6,#0
   // lo(f1)*lo(f2)

rtl/i386/i386.inc

@@ -635,7 +635,7 @@ end;
 ****************************************************************************}
 {$ifndef HAS_GENERICCONSTRUCTOR}
 {$define FPC_SYSTEM_HAS_FPC_HELP_CONSTRUCTOR}
-procedure fpc_help_constructor; assembler; [public,alias:'FPC_HELP_CONSTRUCTOR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_help_constructor; assembler; [public,alias:'FPC_HELP_CONSTRUCTOR']; compilerproc;
 asm
 { Entry without preamble, since we need the ESP of the constructor
   Stack (relative to %ebp):
@@ -723,7 +723,7 @@ end;
 
 
 {$define FPC_SYSTEM_HAS_FPC_HELP_FAIL}
-procedure fpc_help_fail;assembler;[public,alias:'FPC_HELP_FAIL']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_help_fail;assembler;[public,alias:'FPC_HELP_FAIL']; compilerproc;
 { should be called with a object that needs to be
   freed if VMT field is at -1
   %edi contains VMT offset in object again }
@@ -762,7 +762,7 @@ end;
 
 
 {$define FPC_SYSTEM_HAS_FPC_HELP_DESTRUCTOR}
-procedure fpc_help_destructor;assembler;[public,alias:'FPC_HELP_DESTRUCTOR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_help_destructor;assembler;[public,alias:'FPC_HELP_DESTRUCTOR']; compilerproc;
 asm
 { Stack (relative to %ebp):
     12 Self
@@ -806,7 +806,7 @@ end;
 
 
 {$define FPC_SYSTEM_HAS_FPC_NEW_CLASS}
-procedure fpc_new_class;assembler;[public,alias:'FPC_NEW_CLASS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_new_class;assembler;[public,alias:'FPC_NEW_CLASS']; compilerproc;
 asm
         { to be sure in the future, we save also edit }
         pushl   %edi
@@ -843,7 +843,7 @@ end;
 procedure int_dispose_class;external name 'FPC_DISPOSE_CLASS';
 
 {$define FPC_SYSTEM_HAS_FPC_DISPOSE_CLASS}
-procedure fpc_dispose_class;assembler;[public,alias:'FPC_DISPOSE_CLASS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_dispose_class;assembler;[public,alias:'FPC_DISPOSE_CLASS']; compilerproc;
 asm
         { to be sure in the future, we save also edit }
         pushl   %edi
@@ -871,7 +871,7 @@ asm
 end;
 
 {$define FPC_SYSTEM_HAS_FPC_HELP_FAIL_CLASS}
-procedure fpc_help_fail_class;assembler;[public,alias:'FPC_HELP_FAIL_CLASS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_help_fail_class;assembler;[public,alias:'FPC_HELP_FAIL_CLASS']; compilerproc;
 { a non zero class must allways be disposed
   VMT is allways at pos 0 }
 asm
@@ -888,7 +888,7 @@ end;
 
 {$define FPC_SYSTEM_HAS_FPC_CHECK_OBJECT}
 { we want the stack for debugging !! PM }
-procedure fpc_check_object(obj : pointer);[public,alias:'FPC_CHECK_OBJECT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_check_object(obj : pointer);[public,alias:'FPC_CHECK_OBJECT']; compilerproc;
 begin
 asm
         pushl   %edi
@@ -913,7 +913,7 @@ end;
 
 
 {$define FPC_SYSTEM_HAS_FPC_CHECK_OBJECT_EXT}
-procedure fpc_check_object_ext;assembler;[public,alias:'FPC_CHECK_OBJECT_EXT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_check_object_ext;assembler;[public,alias:'FPC_CHECK_OBJECT_EXT']; compilerproc;
 { checks for a correct vmt pointer }
 { deeper check to see if the current object is }
 { really related to the true }
@@ -963,7 +963,7 @@ end;
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_ASSIGN}
 {$define FPC_SYSTEM_HAS_FPC_SHORTSTR_ASSIGN}
 
-function fpc_shortstr_to_shortstr(len:longint; const sstr: shortstring): shortstring; [public,alias: 'FPC_SHORTSTR_TO_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_shortstr_to_shortstr(len:longint; const sstr: shortstring): shortstring; [public,alias: 'FPC_SHORTSTR_TO_SHORTSTR']; compilerproc;
 begin
   asm
         cld
@@ -1041,7 +1041,7 @@ end;
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_CONCAT}
 {$define FPC_SYSTEM_HAS_FPC_SHORTSTR_CONCAT}
 
-function fpc_shortstr_concat(const s1,s2:shortstring):shortstring;{$ifdef hascompilerproc}compilerproc;{$endif}
+function fpc_shortstr_concat(const s1,s2:shortstring):shortstring;compilerproc;
 begin
   asm
         movl    __RESULT,%edi
@@ -1102,7 +1102,6 @@ end;
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_APPEND_SHORTSTR}
 {$define FPC_SYSTEM_HAS_FPC_SHORTSTR_APPEND_SHORTSTR}
 
-{$ifdef hascompilerproc}
 procedure fpc_shortstr_append_shortstr(var s1:shortstring;const s2:shortstring);compilerproc;
     [public,alias:'FPC_SHORTSTR_APPEND_SHORTSTR'];
 begin
@@ -1141,44 +1140,6 @@ begin
         movsb
   end ['EBX','ECX','EAX','ESI','EDI'];
 end;
-{$else hascompilerproc}
-procedure fpc_shortstr_concat_int(const s1,s2:shortstring);[public,alias:'FPC_SHORTSTR_CONCAT'];
-begin
-  asm
-        movl    s1,%esi
-        movl    s2,%edi
-        movl    %edi,%ebx
-        movzbl  (%edi),%ecx
-        xor     %eax,%eax
-        lea     1(%edi,%ecx),%edi
-        negl    %ecx
-        addl    $0x0ff,%ecx
-        lodsb
-        cmpl    %ecx,%eax
-        jbe     .LStrConcat1
-        movl    %ecx,%eax
-.LStrConcat1:
-        addb    %al,(%ebx)
-        cmpl    $7,%eax
-        jl      .LStrConcat2
-        movl    %edi,%ecx       { Align on 32bits }
-        negl    %ecx
-        andl    $3,%ecx
-        subl    %ecx,%eax
-        rep
-        movsb
-        movl    %eax,%ecx
-        andl    $3,%eax
-        shrl    $2,%ecx
-        rep
-        movsl
-.LStrConcat2:
-        movl    %eax,%ecx
-        rep
-        movsb
-  end ['EBX','ECX','EAX','ESI','EDI'];
-end;
-{$endif hascompilerproc}
 {$endif FPC_SYSTEM_HAS_FPC_SHORTSTR_APPEND_SHORTSTR}
 
 
@@ -1242,7 +1203,7 @@ asm
         movl    saveebx,%ebx
 end;
 {$else SHORTSTRCOMPAREINREG}
-function fpc_shortstr_compare(const left,right:shortstring): longint; [public,alias:'FPC_SHORTSTR_COMPARE']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_shortstr_compare(const left,right:shortstring): longint; [public,alias:'FPC_SHORTSTR_COMPARE']; compilerproc;
 begin
   asm
         cld
@@ -1296,14 +1257,14 @@ end;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_PCHAR_TO_SHORTSTR}
 {$define FPC_SYSTEM_HAS_FPC_PCHAR_TO_SHORTSTR}
-function fpc_pchar_to_shortstr(p:pchar):shortstring;assembler;[public,alias:'FPC_PCHAR_TO_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_pchar_to_shortstr(p:pchar):shortstring;assembler;[public,alias:'FPC_PCHAR_TO_SHORTSTR']; compilerproc;
 {$include strpas.inc}
 {$endif FPC_SYSTEM_HAS_FPC_PCHAR_TO_SHORTSTR}
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_PCHAR_LENGTH}
 {$define FPC_SYSTEM_HAS_FPC_PCHAR_LENGTH}
-function fpc_pchar_length(p:pchar):longint;assembler;[public,alias:'FPC_PCHAR_LENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_pchar_length(p:pchar):longint;assembler;[public,alias:'FPC_PCHAR_LENGTH']; compilerproc;
 {$include strlen.inc}
 {$endif FPC_SYSTEM_HAS_FPC_PCHAR_LENGTH}
 

rtl/i386/int64p.inc

@@ -16,7 +16,7 @@
 {$R- no range checking }
 
 {$define FPC_SYSTEM_HAS_DIV_QWORD}
-    function fpc_div_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_DIV_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_div_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_DIV_QWORD']; compilerproc;
       var
          shift,lzz,lzn : longint;
          saveebx,saveedi : longint;
@@ -90,7 +90,7 @@
 
 
 {$define FPC_SYSTEM_HAS_MOD_QWORD}
-    function fpc_mod_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_MOD_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mod_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_MOD_QWORD']; compilerproc;
       var
          shift,lzz,lzn : longint;
          saveebx,saveedi : longint;
@@ -171,7 +171,7 @@
     { multiplies two qwords
       the longbool for checkoverflow avoids a misaligned stack
     }
-    function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;[public,alias: 'FPC_MUL_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;[public,alias: 'FPC_MUL_QWORD']; compilerproc;
       var
         r : qword;
         overflowed : boolean;

rtl/i386/math.inc

@@ -230,12 +230,8 @@
   {$ifdef internconstintf}
     function fpc_round_real(d : ValReal) : int64;assembler;compilerproc;
   {$else}
-    {$ifdef hascompilerproc}
       function round(d : ValReal) : int64;[internconst:fpc_in_const_round, external name 'FPC_ROUND'];
-      function fpc_round(d : ValReal) : int64;assembler;[public, alias:'FPC_ROUND'];{$ifdef hascompilerproc}compilerproc;{$endif hascompilerproc}
-    {$else}
-      function round(d : ValReal) : int64;assembler;[internconst:fpc_in_const_round];
-    {$endif hascompilerproc}
+      function fpc_round(d : ValReal) : int64;assembler;[public, alias:'FPC_ROUND'];compilerproc;
   {$endif}
       var
         res   : int64;

rtl/i386/set.inc

@@ -15,7 +15,7 @@
 
 
 {$define FPC_SYSTEM_HAS_FPC_SET_LOAD_SMALL}
-function fpc_set_load_small(l: fpc_small_set): fpc_normal_set;assembler;[public,alias:'FPC_SET_LOAD_SMALL']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_set_load_small(l: fpc_small_set): fpc_normal_set;assembler;[public,alias:'FPC_SET_LOAD_SMALL']; compilerproc;
 {
   load a normal set p from a smallset l
 }
@@ -35,17 +35,13 @@ end;
 
 {$define FPC_SYSTEM_HAS_FPC_SET_CREATE_ELEMENT}
 
-function fpc_set_create_element(b : byte): fpc_normal_set;assembler;[public,alias:'FPC_SET_CREATE_ELEMENT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_set_create_element(b : byte): fpc_normal_set;assembler;[public,alias:'FPC_SET_CREATE_ELEMENT']; compilerproc;
 {
   create a new set in p from an element b
 }
 var
   saveedi : longint;
 asm
-{$ifndef hascompilerproc}
-        pushl   %eax
-        pushl   %ecx
-{$endif not hascompilerproc}
         movl    %edi,saveedi
         movl    __RESULT,%edi
         movzbl  b,%edx
@@ -56,15 +52,10 @@ asm
         leal    -32(%edi),%eax
         btsl    %edx,(%eax)
         movl    saveedi,%edi
-{$ifndef hascompilerproc}
-        popl    %ecx
-        popl    %eax
-{$endif hascompilerproc}
 end;
 
 
 {$define FPC_SYSTEM_HAS_FPC_SET_SET_BYTE}
-{$ifdef hascompilerproc}
 function fpc_set_set_byte(const source: fpc_normal_set; b : byte): fpc_normal_set;assembler; compilerproc;
 {
   add the element b to the set pointed by source
@@ -85,28 +76,8 @@ asm
         movl    saveedi,%edi
         movl    saveesi,%esi
 end;
-{$else hascompilerproc}
-function fpc_set_set_byte(b : byte): fpc_normal_set;assembler;[public,alias:'FPC_SET_SET_BYTE'];
-{
-  add the element b to the set pointed by p
-}
-asm
-       pushl %eax
-       movl __RESULT,%edi
-       movb b,%al
-       andl $0xf8,%eax
-       shrl $3,%eax
-       addl %eax,%edi
-       movb b,%al
-       andl $7,%eax
-       btsl %eax,(%edi)
-       popl %eax
-end;
-{$endif hascompilerproc}
-
 
 {$define FPC_SYSTEM_HAS_FPC_SET_UNSET_BYTE}
-{$ifdef hascompilerproc}
 function fpc_set_unset_byte(const source: fpc_normal_set; b : byte): fpc_normal_set;assembler; compilerproc;
 {
   add the element b to the set pointed by source
@@ -127,30 +98,9 @@ asm
         movl    saveedi,%edi
         movl    saveesi,%esi
 end;
-{$else hascompilerproc}
-function fpc_set_unset_byte(b : byte): fpc_normal_set;assembler;[public,alias:'FPC_SET_UNSET_BYTE']; {$ifdef hascompilerproc} compilerproc; {$endif}
-{
-  suppresses the element b to the set pointed by p
-  used for exclude(set,element)
-}
-asm
-       pushl %eax
-       movl __RESULT,%edi
-       movb b,%al
-       andl $0xf8,%eax
-       shrl $3,%eax
-       addl %eax,%edi
-       movb b,%al
-       andl $7,%eax
-       btrl %eax,(%edi)
-       popl %eax
-end;
-{$endif hascompilerproc}
-
 
 {$define FPC_SYSTEM_HAS_FPC_SET_SET_RANGE}
 
-{$ifdef hascompilerproc}
 function fpc_set_set_range(const orgset: fpc_normal_set; l,h : byte): fpc_normal_set;assembler; compilerproc;
 {
   adds the range [l..h] to the set pointed to by p
@@ -210,61 +160,13 @@ asm
         movl    saveebx,%ebx
 end;
 
-{$else hascompilerproc}
-
-function fpc_set_set_range(l,h : byte): fpc_normal_set;assembler;[public,alias:'FPC_SET_SET_RANGE'];
-{
-  adds the range [l..h] to the set pointed to by p
-}
-asm
-        movl    __RESULT,%edi               // set address in edi
-        movzbl  l,%eax              // lowest bit to be set in eax
-        movzbl  h,%ebx              // highest in ebx
-        cmpl   %eax,%ebx
-        jb     .Lset_range_done
-        movl   %eax,%ecx            // lowest also in ecx
-        shrl   $3,%eax              // divide by 8 to get starting and ending byte
-        shrl   $3,%ebx              // address
-        andb   $31,%cl              // low five bits of lo determine start of bit mask
-        movl   $0x0ffffffff,%edx    // edx = bitmask to be inserted
-        andl   $0x0fffffffc,%eax    // clear two lowest bits to get start/end longint
-        andl   $0x0fffffffc,%ebx    // address * 4
-        shll   %cl,%edx             // shift bitmask to clear bits below lo
-        addl   %eax,%edi            // go to starting pos in set
-        subl   %eax,%ebx            // are bit lo and hi in the same longint?
-        jz     .Lset_range_hi       // yes, keep current mask and adjust for hi bit
-        orl    %edx,(%edi)          // no, store current mask
-        movl   $0x0ffffffff,%edx    // new mask
-        addl   $4,%edi              // next longint of set
-        subl   $4,%ebx              // bit hi in this longint?
-        jz     .Lset_range_hi       // yes, keep full mask and adjust for hi bit
-.Lset_range_loop:
-        movl   %edx,(%edi)          // no, fill longints in between with full mask
-        addl   $4,%edi
-        subl   $4,%ebx
-        jnz    .Lset_range_loop
-.Lset_range_hi:
-        movb   h,%cl
-        movl   %edx,%ebx            // save current bitmask
-        andb   $31,%cl
-        subb   $31,%cl              // cl := (31 - (hi and 31)) = shift count to
-        negb   %cl                  // adjust bitmask for hi bit
-        shrl   %cl,%edx             // shift bitmask to clear bits higher than hi
-        andl   %edx,%ebx            // combine both bitmasks
-        orl    %ebx,(%edi)          // store to set
-.Lset_range_done:
-end;
-{$endif hascompilerproc}
-
-
 {$define FPC_SYSTEM_HAS_FPC_SET_IN_BYTE}
 
-function fpc_set_in_byte(const p: fpc_normal_set; b: byte): boolean; assembler; [public,alias:'FPC_SET_IN_BYTE']; {$ifdef hascompilerproc} compilerproc; {$else} {$ifndef NOSAVEREGISTERS}saveregisters;{$endif} {$endif}
+function fpc_set_in_byte(const p: fpc_normal_set; b: byte): boolean; assembler; [public,alias:'FPC_SET_IN_BYTE']; compilerproc;
 {
   tests if the element b is in the set p the carryflag is set if it present
 }
 asm
-{$ifdef hascompilerproc}
 {$ifdef REGCALL}
         xchgl %edx,%eax
         andl $0xff,%eax
@@ -273,23 +175,12 @@ asm
        movzbl b,%eax
 {$endif}
        btl %eax,(%edx)
-{$else hascompilerproc}
-       pushl %eax
-       movl   p,%edi
-       movzbl b,%eax
-       btl %eax,(%edi)
-       popl %eax
-{$endif hascompilerproc}
 end;
 
 
 {$define FPC_SYSTEM_HAS_FPC_SET_ADD_SETS}
 
-{$ifdef hascompilerproc}
 function fpc_set_add_sets(const set1,set2: fpc_normal_set): fpc_normal_set;assembler;[public,alias:'FPC_SET_ADD_SETS']; compilerproc;
-{$else hascompilerproc}
-procedure fpc_set_add_sets(set1,set2,dest : pointer);assembler;[public,alias:'FPC_SET_ADD_SETS'];
-{$endif hascompilerproc}
 {
   adds set1 and set2 into set dest
 }
@@ -305,11 +196,7 @@ asm
 {$else}
       movl set1,%esi
       movl set2,%edx
-{$ifdef hascompilerproc}
       movl __RESULT,%edi
-{$else hascompilerproc}
-      movl dest,%edi
-{$endif hascompilerproc}
 {$endif}
       movl $8,%ecx
    .LMADDSETS1:
@@ -326,11 +213,7 @@ end;
 
 {$define FPC_SYSTEM_HAS_FPC_SET_MUL_SETS}
 
-{$ifdef hascompilerproc}
 function fpc_set_mul_sets(const set1,set2: fpc_normal_set): fpc_normal_set;assembler;[public,alias:'FPC_SET_MUL_SETS']; compilerproc;
-{$else hascompilerproc}
-procedure fpc_set_mul_sets(set1,set2,dest:pointer);assembler;[public,alias:'FPC_SET_MUL_SETS'];
-{$endif hascompilerproc}
 {
   multiplies (takes common elements of) set1 and set2 result put in dest
 }
@@ -346,11 +229,7 @@ asm
 {$else}
       movl set1,%esi
       movl set2,%edx
-{$ifdef hascompilerproc}
       movl __RESULT,%edi
-{$else hascompilerproc}
-      movl dest,%edi
-{$endif hascompilerproc}
 {$endif}
       movl $8,%ecx
   .LMMULSETS1:
@@ -367,11 +246,7 @@ end;
 
 {$define FPC_SYSTEM_HAS_FPC_SET_SUB_SETS}
 
-{$ifdef hascompilerproc}
 function fpc_set_sub_sets(const set1,set2: fpc_normal_set): fpc_normal_set;assembler;[public,alias:'FPC_SET_SUB_SETS']; compilerproc;
-{$else hascompilerproc}
-procedure fpc_set_sub_sets(set1,set2,dest:pointer);assembler;[public,alias:'FPC_SET_SUB_SETS'];
-{$endif hascompilerproc}
 {
   computes the diff from set1 to set2 result in dest
 }
@@ -388,11 +263,7 @@ asm
 {$else}
         movl set1,%esi
         movl set2,%ebx
-{$ifdef hascompilerproc}
       movl __RESULT,%edi
-{$else hascompilerproc}
-      movl dest,%edi
-{$endif hascompilerproc}
 {$endif}
         movl $8,%ecx
     .LMSUBSETS1:
@@ -412,11 +283,7 @@ end;
 
 {$define FPC_SYSTEM_HAS_FPC_SET_SYMDIF_SETS}
 
-{$ifdef hascompilerproc}
 function fpc_set_symdif_sets(const set1,set2: fpc_normal_set): fpc_normal_set;assembler;[public,alias:'FPC_SET_SYMDIF_SETS']; compilerproc;
-{$else hascompilerproc}
-procedure fpc_set_symdif_sets(set1,set2,dest:pointer);assembler;[public,alias:'FPC_SET_SYMDIF_SETS'];
-{$endif hascompilerproc}
 {
    computes the symetric diff from set1 to set2 result in dest
 }
@@ -432,11 +299,7 @@ asm
 {$else}
         movl set1,%esi
         movl set2,%edx
-{$ifdef hascompilerproc}
       movl __RESULT,%edi
-{$else hascompilerproc}
-      movl dest,%edi
-{$endif hascompilerproc}
 {$endif}
         movl $8,%ecx
     .LMSYMDIFSETS1:
@@ -453,7 +316,7 @@ end;
 
 {$define FPC_SYSTEM_HAS_FPC_SET_COMP_SETS}
 
-function fpc_set_comp_sets(const set1,set2: fpc_normal_set): boolean;assembler;[public,alias:'FPC_SET_COMP_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_set_comp_sets(const set1,set2: fpc_normal_set): boolean;assembler;[public,alias:'FPC_SET_COMP_SETS']; compilerproc;
 {
   compares set1 and set2 zeroflag is set if they are equal
 }
@@ -477,9 +340,7 @@ asm
         { we are here only if the two sets are equal
           we have zero flag set, and that what is expected }
     .LMCOMPSETEND:
-{$ifdef hascompilerproc}
         seteb %al
-{$endif hascompilerproc}
         movl    saveedi,%edi
         movl    saveesi,%esi
 end;
@@ -487,7 +348,7 @@ end;
 
 {$define FPC_SYSTEM_HAS_FPC_SET_CONTAINS_SET}
 
-function fpc_set_contains_sets(const set1,set2: fpc_normal_set): boolean;assembler;[public,alias:'FPC_SET_CONTAINS_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_set_contains_sets(const set1,set2: fpc_normal_set): boolean;assembler;[public,alias:'FPC_SET_CONTAINS_SETS']; compilerproc;
 {
   on exit, zero flag is set if set1 <= set2 (set2 contains set1)
 }
@@ -512,9 +373,7 @@ asm
         { we are here only if set2 contains set1
           we have zero flag set, and that what is expected }
     .LMCONTAINSSETEND:
-{$ifdef hascompilerproc}
         seteb %al
-{$endif hascompilerproc}
         movl    saveedi,%edi
         movl    saveesi,%esi
 end;
@@ -524,7 +383,7 @@ end;
 
 {$error Needs to be fixed for register calling first!}
 
-procedure fpc_largeset_set_word(p : pointer;b : word);assembler;[public,alias:'FPC_LARGESET_SET_WORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_set_word(p : pointer;b : word);assembler;[public,alias:'FPC_LARGESET_SET_WORD']; compilerproc;
 {
   sets the element b in set p works for sets larger than 256 elements
   not yet use by the compiler so
@@ -543,7 +402,7 @@ asm
 end;
 
 
-procedure fpc_largeset_in_word(p : pointer;b : word);assembler;[public,alias:'FPC_LARGESET_IN_WORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_in_word(p : pointer;b : word);assembler;[public,alias:'FPC_LARGESET_IN_WORD']; compilerproc;
 {
   tests if the element b is in the set p the carryflag is set if it present
   works for sets larger than 256 elements
@@ -562,7 +421,7 @@ asm
 end;
 
 
-procedure fpc_largeset_add_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_ADD_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_add_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_ADD_SETS']; compilerproc;
 {
   adds set1 and set2 into set dest size is the number of bytes in the set
 }
@@ -581,7 +440,7 @@ asm
 end;
 
 
-procedure fpc_largeset_mul_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_MUL_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_mul_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_MUL_SETS']; compilerproc;
 {
   multiplies (i.E. takes common elements of) set1 and set2 result put in
   dest size is the number of bytes in the set
@@ -601,7 +460,7 @@ asm
 end;
 
 
-procedure fpc_largeset_sub_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_SUB_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_sub_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_SUB_SETS']; compilerproc;
 asm
          movl set1,%esi
          movl set2,%ebx
@@ -619,7 +478,7 @@ asm
 end;
 
 
-procedure fpc_largeset_symdif_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_SYMDIF_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_symdif_sets(set1,set2,dest : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_SYMDIF_SETS']; compilerproc;
 {
    computes the symetric diff from set1 to set2 result in dest
 }
@@ -639,7 +498,7 @@ asm
 end;
 
 
-procedure fpc_largeset_comp_sets(set1,set2 : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_COMP_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_comp_sets(set1,set2 : pointer;size : longint);assembler;[public,alias:'FPC_LARGESET_COMP_SETS']; compilerproc;
 asm
       movl set1,%esi
       movl set2,%edi
@@ -657,7 +516,7 @@ asm
   .LMCOMPSETSIZEEND:
 end;
 
-procedure fpc_largeset_contains_sets(set1,set2 : pointer; size: longint);assembler;[public,alias:'FPC_LARGESET_CONTAINS_SETS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_largeset_contains_sets(set1,set2 : pointer; size: longint);assembler;[public,alias:'FPC_LARGESET_CONTAINS_SETS']; compilerproc;
 {
   on exit, zero flag is set if set1 <= set2 (set2 contains set1)
 }

rtl/inc/astrings.inc

@@ -36,16 +36,9 @@
 Type
   PAnsiRec = ^TAnsiRec;
   TAnsiRec = Packed Record
-{$ifndef hascompilerproc}
-    Maxlen,
-    len,
-    ref   : Longint;
-    First : Char;
-{$else}
     Ref,
     Len   : SizeInt;
     First : Char;
-{$endif}
   end;
 
 Const
@@ -93,7 +86,7 @@ begin
 end;
 
 
-Procedure fpc_AnsiStr_Decr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_ANSISTR_DECR_REF'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_Decr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_ANSISTR_DECR_REF'];  compilerproc;
 {
   Decreases the ReferenceCount of a non constant ansistring;
   If the reference count is zero, deallocate the string;
@@ -118,16 +111,10 @@ Begin
 {$endif}
 end;
 
-{$ifdef hascompilerproc}
 { also define alias for internal use in the system unit }
 Procedure fpc_AnsiStr_Decr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [external name 'FPC_ANSISTR_DECR_REF'];
-{$endif hascompilerproc}
 
-{$ifdef hascompilerproc}
-Procedure fpc_AnsiStr_Incr_Ref (S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_ANSISTR_INCR_REF'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-{$else}
-Procedure fpc_AnsiStr_Incr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_ANSISTR_INCR_REF'];
-{$endif}
+Procedure fpc_AnsiStr_Incr_Ref (S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_ANSISTR_INCR_REF'];  compilerproc;
 Begin
   If S=Nil then
     exit;
@@ -136,12 +123,10 @@ Begin
   inclocked(PAnsiRec(S-FirstOff)^.Ref);
 end;
 
-{$ifdef hascompilerproc}
 { also define alias which can be used inside the system unit }
 Procedure fpc_AnsiStr_Incr_Ref (S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[external name 'FPC_ANSISTR_INCR_REF'];
-{$endif hascompilerproc}
 
-Procedure fpc_AnsiStr_Assign (Var S1 : Pointer;S2 : Pointer);[Public,Alias:'FPC_ANSISTR_ASSIGN'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_Assign (Var S1 : Pointer;S2 : Pointer);[Public,Alias:'FPC_ANSISTR_ASSIGN'];  compilerproc;
 {
   Assigns S2 to S1 (S1:=S2), taking in account reference counts.
 }
@@ -155,18 +140,12 @@ begin
   S1:=S2;
 end;
 
-{$ifdef hascompilerproc}
 { alias for internal use }
 Procedure fpc_AnsiStr_Assign (Var S1 : Pointer;S2 : Pointer);[external name 'FPC_ANSISTR_ASSIGN'];
-{$endif hascompilerproc}
 
-{$ifdef hascompilerproc}
 function fpc_AnsiStr_Concat (const S1,S2 : AnsiString): ansistring; compilerproc;
 var
   S3: ansistring absolute result;
-{$else hascompilerproc}
-Procedure fpc_AnsiStr_Concat (const S1,S2 : ansistring;var S3 : ansistring);[Public, alias: 'FPC_ANSISTR_CONCAT'];
-{$endif hascompilerproc}
 {
   Concatenates 2 AnsiStrings : S1+S2.
   Result Goes to S3;
@@ -219,7 +198,7 @@ end;
 { procedure fpc_AnsiStr_To_ShortStr (Var S1 : ShortString;S2 : Pointer);     }
 { which is what the old helper was, so we don't need an extra implementation }
 { of the old helper (JM)                                                     }
-function fpc_AnsiStr_To_ShortStr (high_of_res: SizeInt;const S2 : Ansistring): shortstring;[Public, alias: 'FPC_ANSISTR_TO_SHORTSTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_AnsiStr_To_ShortStr (high_of_res: SizeInt;const S2 : Ansistring): shortstring;[Public, alias: 'FPC_ANSISTR_TO_SHORTSTR'];  compilerproc;
 {
   Converts a AnsiString to a ShortString;
 }
@@ -239,7 +218,7 @@ begin
 end;
 
 
-Function fpc_ShortStr_To_AnsiStr (Const S2 : ShortString): ansistring; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_ShortStr_To_AnsiStr (Const S2 : ShortString): ansistring; compilerproc;
 {
   Converts a ShortString to a AnsiString;
 }
@@ -252,20 +231,7 @@ begin
     Move(S2[1],Pointer(fpc_ShortStr_To_AnsiStr)^,Size);
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_ShortStr_To_AnsiStr (Var S1 : Pointer; Const S2 : ShortString);[Public, alias: 'FPC_SHORTSTR_TO_ANSISTR'];
-Var
-  Size : SizeInt;
-begin
-  Size:=Length(S2);
-  Setlength (ansistring(s1),Size);
-  if Size>0 then
-    Move(S2[1],s1^,Size);
-end;
-{$endif hascompilerproc}
-
-Function fpc_Char_To_AnsiStr(const c : Char): AnsiString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Char_To_AnsiStr(const c : Char): AnsiString; compilerproc;
 {
   Converts a Char to a AnsiString;
 }
@@ -276,16 +242,8 @@ begin
   PByte(Pointer(fpc_Char_To_AnsiStr)+1)^:=0;
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_Char_To_AnsiStr(var S1 : Pointer; c : Char);[Public, alias: 'FPC_CHAR_TO_ANSISTR'];
-begin
-  s1 := pointer(fpc_Char_To_AnsiStr(c));
-end;
-{$endif hascompilerproc}
 
-
-Function fpc_PChar_To_AnsiStr(const p : pchar): ansistring; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_PChar_To_AnsiStr(const p : pchar): ansistring; compilerproc;
 Var
   L : SizeInt;
 begin
@@ -297,16 +255,9 @@ begin
   Move (P[0],Pointer(fpc_PChar_To_AnsiStr)^,L)
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_PChar_To_AnsiStr(var a : ansistring;p : pchar);[Public,Alias : 'FPC_PCHAR_TO_ANSISTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-begin
-  pointer(a) := pointer(fpc_PChar_To_AnsiStr(p));
-end;
-{$endif hascompilerproc}
 
 
-Function fpc_CharArray_To_AnsiStr(const arr: array of char): ansistring; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_CharArray_To_AnsiStr(const arr: array of char): ansistring; compilerproc;
 var
   i  : SizeInt;
 begin
@@ -320,33 +271,6 @@ begin
   Move (arr[0],Pointer(fpc_CharArray_To_AnsiStr)^,i);
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-{ the declaration below is the same as                                              }
-{ which is what the old helper was (we need the parameter as "array of char" type   }
-{ so we can pass it to the new style helper (JM)                                    }
-Procedure fpc_CharArray_To_AnsiStr(var a : ansistring; p: pointer; len: SizeInt);[Public,Alias : 'FPC_CHARARRAY_TO_ANSISTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-var
-  src: pchar;
-  i: SizeInt;
-begin
-  src := pchar(p);
-  if src[0]=#0 Then
-    { result is automatically set to '' }
-    begin
-      pointer(a) := nil;
-      exit;
-    end;
-  i:=IndexChar(src^,len,#0);
-  if i = -1 then
-    i := len;
-  pointer(a) := NewAnsiString(i);
-  Move (src^,a[1],i);
-end;
-{$endif not hascompilerproc}
-
-
-{$ifdef hascompilerproc}
 
 { note: inside the compiler, the resulttype is modified to be the length }
 { of the actual chararray to which we convert (JM)                       }
@@ -363,10 +287,9 @@ begin
   fillchar(fpc_ansistr_to_chararray[len],arraysize-len,0);
 end;
 
-{$endif hascompilerproc}
 
 
-Function fpc_AnsiStr_Compare(const S1,S2 : AnsiString): SizeInt;[Public,Alias : 'FPC_ANSISTR_COMPARE'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_AnsiStr_Compare(const S1,S2 : AnsiString): SizeInt;[Public,Alias : 'FPC_ANSISTR_COMPARE'];  compilerproc;
 {
   Compares 2 AnsiStrings;
   The result is
@@ -397,20 +320,20 @@ begin
 end;
 
 
-Procedure fpc_AnsiStr_CheckZero(p : pointer);[Public,Alias : 'FPC_ANSISTR_CHECKZERO'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_CheckZero(p : pointer);[Public,Alias : 'FPC_ANSISTR_CHECKZERO'];  compilerproc;
 begin
   if p=nil then
     HandleErrorFrame(201,get_frame);
 end;
 
 
-Procedure fpc_AnsiStr_CheckRange(len,index : SizeInt);[Public,Alias : 'FPC_ANSISTR_RANGECHECK'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_CheckRange(len,index : SizeInt);[Public,Alias : 'FPC_ANSISTR_RANGECHECK'];  compilerproc;
 begin
   if (index>len) or (Index<1) then
     HandleErrorFrame(201,get_frame);
 end;
 
-Procedure fpc_AnsiStr_SetLength (Var S : AnsiString; l : SizeInt);[Public,Alias : 'FPC_ANSISTR_SETLENGTH'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_SetLength (Var S : AnsiString; l : SizeInt);[Public,Alias : 'FPC_ANSISTR_SETLENGTH'];  compilerproc;
 {
   Sets The length of string S to L.
   Makes sure S is unique, and contains enough room.
@@ -462,7 +385,7 @@ begin
 end;
 
 {$ifdef EXTRAANSISHORT}
-Function fpc_AnsiStr_ShortStr_Compare (Var S1 : Pointer; Var S2 : ShortString): SizeInt;  {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_AnsiStr_ShortStr_Compare (Var S1 : Pointer; Var S2 : ShortString): SizeInt;  compilerproc;
 {
   Compares a AnsiString with a ShortString;
   The result is
@@ -493,11 +416,7 @@ end;
 *****************************************************************************}
 
 
-{$ifdef HASCOMPILERPROC}
-Function fpc_ansistr_Unique(Var S : Pointer): Pointer; [Public,Alias : 'FPC_ANSISTR_UNIQUE']; {$ifdef hascompilerproc} compilerproc; {$endif}
-{$else}
-Procedure fpc_ansistr_Unique(Var S : AnsiString); [Public,Alias : 'FPC_ANSISTR_UNIQUE'];
-{$endif}
+Function fpc_ansistr_Unique(Var S : Pointer): Pointer; [Public,Alias : 'FPC_ANSISTR_UNIQUE']; compilerproc;
 {
   Make sure reference count of S is 1,
   using copy-on-write semantics.
@@ -506,9 +425,7 @@ Var
   SNew : Pointer;
   L    : SizeInt;
 begin
-{$ifdef HASCOMPILERPROC}
   pointer(result) := pointer(s);
-{$endif}
   If Pointer(S)=Nil then
     exit;
   if PAnsiRec(Pointer(S)-Firstoff)^.Ref<>1 then
@@ -519,20 +436,18 @@ begin
      PAnsiRec(SNew-FirstOff)^.len:=L;
      fpc_ansistr_decr_ref (Pointer(S));  { Thread safe }
      pointer(S):=SNew;
-{$ifdef HASCOMPILERPROC}
      pointer(result):=SNew;
-{$endif}
    end;
 end;
 
-Procedure fpc_ansistr_append_char(Var S : AnsiString;c : char); [Public,Alias : 'FPC_ANSISTR_APPEND_CHAR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_ansistr_append_char(Var S : AnsiString;c : char); [Public,Alias : 'FPC_ANSISTR_APPEND_CHAR']; compilerproc;
 begin
    SetLength(S,length(S)+1);
    S[length(S)]:=c;
    PByte(Pointer(S)+length(S))^:=0; { Terminating Zero }
 end;
 
-Procedure fpc_ansistr_append_shortstring(Var S : AnsiString;Str : ShortString); [Public,Alias : 'FPC_ANSISTR_APPEND_SHORTSTRING']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_ansistr_append_shortstring(Var S : AnsiString;Str : ShortString); [Public,Alias : 'FPC_ANSISTR_APPEND_SHORTSTRING']; compilerproc;
 var
    ofs : SizeInt;
 begin
@@ -544,7 +459,7 @@ begin
    PByte(Pointer(S)+length(S))^:=0; { Terminating Zero }
 end;
 
-Procedure fpc_ansistr_append_ansistring(Var S : AnsiString;Str : AnsiString); [Public,Alias : 'FPC_ANSISTR_APPEND_ANSISTRING']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_ansistr_append_ansistring(Var S : AnsiString;Str : AnsiString); [Public,Alias : 'FPC_ANSISTR_APPEND_ANSISTRING']; compilerproc;
 var
    ofs : SizeInt;
 begin
@@ -633,7 +548,7 @@ begin
 end;
 
 
-Function fpc_Val_Real_AnsiStr(Const S : AnsiString; Var Code : ValSInt): ValReal; [public, alias:'FPC_VAL_REAL_ANSISTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_Real_AnsiStr(Const S : AnsiString; Var Code : ValSInt): ValReal; [public, alias:'FPC_VAL_REAL_ANSISTR']; compilerproc;
 Var
   SS : String;
 begin
@@ -648,7 +563,7 @@ begin
 end;
 
 
-Function fpc_Val_UInt_AnsiStr (Const S : AnsiString; Var Code : ValSInt): ValUInt; [public, alias:'FPC_VAL_UINT_ANSISTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_UInt_AnsiStr (Const S : AnsiString; Var Code : ValSInt): ValUInt; [public, alias:'FPC_VAL_UINT_ANSISTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -663,7 +578,7 @@ begin
 end;
 
 
-Function fpc_Val_SInt_AnsiStr (DestSize: SizeInt; Const S : AnsiString; Var Code : ValSInt): ValSInt; [public, alias:'FPC_VAL_SINT_ANSISTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_SInt_AnsiStr (DestSize: SizeInt; Const S : AnsiString; Var Code : ValSInt): ValSInt; [public, alias:'FPC_VAL_SINT_ANSISTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -680,7 +595,7 @@ end;
 
 {$ifndef CPU64}
 
-Function fpc_Val_qword_AnsiStr (Const S : AnsiString; Var Code : ValSInt): qword; [public, alias:'FPC_VAL_QWORD_ANSISTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_qword_AnsiStr (Const S : AnsiString; Var Code : ValSInt): qword; [public, alias:'FPC_VAL_QWORD_ANSISTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -695,7 +610,7 @@ begin
 end;
 
 
-Function fpc_Val_int64_AnsiStr (Const S : AnsiString; Var Code : ValSInt): Int64; [public, alias:'FPC_VAL_INT64_ANSISTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_int64_AnsiStr (Const S : AnsiString; Var Code : ValSInt): Int64; [public, alias:'FPC_VAL_INT64_ANSISTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -712,7 +627,7 @@ end;
 {$endif CPU64}
 
 
-procedure fpc_AnsiStr_Float(d : ValReal;len,fr,rt : SizeInt;var s : ansistring);[public,alias:'FPC_ANSISTR_FLOAT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_AnsiStr_Float(d : ValReal;len,fr,rt : SizeInt;var s : ansistring);[public,alias:'FPC_ANSISTR_FLOAT']; compilerproc;
 var
   ss: ShortString;
 begin
@@ -722,9 +637,9 @@ end;
 
 
 {$ifdef STR_USES_VALINT}
-Procedure fpc_AnsiStr_UInt(v : ValUInt;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_VALUINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_UInt(v : ValUInt;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_VALUINT']; compilerproc;
 {$else}
-Procedure fpc_AnsiStr_Longword(v : Longword;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_CARDINAL']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_Longword(v : Longword;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_CARDINAL']; compilerproc;
 {$endif}
 Var
   SS : ShortString;
@@ -736,9 +651,9 @@ end;
 
 
 {$ifdef STR_USES_VALINT}
-Procedure fpc_AnsiStr_SInt(v : ValSInt;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_VALSINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_SInt(v : ValSInt;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_VALSINT']; compilerproc;
 {$else}
-Procedure fpc_AnsiStr_Longint(v : Longint; Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_LONGINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_Longint(v : Longint; Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_LONGINT']; compilerproc;
 {$endif}
 Var
   SS : ShortString;
@@ -750,7 +665,7 @@ end;
 
 {$ifndef CPU64}
 
-Procedure fpc_AnsiStr_QWord(v : QWord;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_QWord(v : QWord;Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_QWORD']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -760,7 +675,7 @@ end;
 
 
 
-Procedure fpc_AnsiStr_Int64(v : Int64; Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_AnsiStr_Int64(v : Int64; Len : SizeInt; Var S : AnsiString);[Public,Alias : 'FPC_ANSISTR_INT64']; compilerproc;
 Var
   SS : ShortString;
 begin

rtl/inc/cgeneric.inc

@@ -139,7 +139,7 @@ end;
 
 function libc_pchar_length(p:pchar):cardinal; cdecl; external 'c' name 'strlen';
 
-function fpc_pchar_length(p:pchar):longint;[public,alias:'FPC_PCHAR_LENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_pchar_length(p:pchar):longint;[public,alias:'FPC_PCHAR_LENGTH']; compilerproc;
 begin
   fpc_pchar_length:=libc_pchar_length(p);
 end;

rtl/inc/cgenmath.inc

@@ -84,9 +84,7 @@
   {$ifdef INTERNCONSTINTF}
     function fpc_sqrt_real(d:Real):Real;compilerproc; {$ifdef MATHINLINE}inline;{$endif}
   {$else}
-    {$ifdef hascompilerproc}
     function fpc_sqrt_real(d:Real):Real;compilerproc; external name 'FPC_SQRT_REAL';
-    {$endif hascompilerproc}
     function sqrt(d:Real):Real;[internconst:fpc_in_const_sqrt];[public, alias: 'FPC_SQRT_REAL']; {$ifdef MATHINLINE}inline;{$endif}
   {$endif}
     begin
@@ -119,19 +117,12 @@ Not supported on Mac OS X 10.1
 
     function c_llround(d: double): int64; cdecl; external 'c' name 'llround';
 
-{$ifdef hascompilerproc}
     function round(d : Real) : int64;{$ifndef INTERNCONSTINTF}[internconst:fpc_in_const_round];{$endif} external name 'FPC_ROUND';
 
-    function fpc_round(d : Real) : int64;[public, alias:'FPC_ROUND'];{$ifdef hascompilerproc}compilerproc;{$endif hascompilerproc}
+    function fpc_round(d : Real) : int64;[public, alias:'FPC_ROUND'];compilerproc;
     begin
       fpc_round := c_llround(d);
     end;
-{$else}
-    function round(d : Real) : int64;{$ifndef INTERNCONSTINTF}[internconst:fpc_in_const_round];{$endif}
-    begin
-      round := c_llround(d);
-    end;
-{$endif hascompilerproc}
 {$endif}
 *)
 

rtl/inc/compproc.inc

@@ -30,7 +30,6 @@ type
   fpc_small_set = longint;
   fpc_normal_set = array[0..7] of longint;
 
-{$ifdef hascompilerproc}
 
 { Needed to solve overloading problem with call from assembler (PFV) }
 {$ifdef valuegetmem}
@@ -182,8 +181,8 @@ Function fpc_PWideChar_To_WideStr(const p : pwidechar): widestring; compilerproc
 Function fpc_PWideChar_To_ShortStr(const p : pwidechar): shortstring; compilerproc;
 
 { from text.inc }
-Function fpc_get_input:PText;{$ifdef hascompilerproc}compilerproc;{$endif}
-Function fpc_get_output:PText;{$ifdef hascompilerproc}compilerproc;{$endif}
+Function fpc_get_input:PText;compilerproc;
+Function fpc_get_output:PText;compilerproc;
 Procedure fpc_Write_End(var f:Text); compilerproc;
 Procedure fpc_Writeln_End(var f:Text); compilerproc;
 Procedure fpc_Write_Text_ShortStr(Len : Longint;var f : Text;const s : String); compilerproc;
@@ -352,5 +351,4 @@ function fpc_int64_to_double(i: int64): double; compilerproc;
 function fpc_qword_to_double(q: qword): double; compilerproc;
 {$endif FPC_INCLUDE_SOFTWARE_INT64_TO_DOUBLE}
 
-{$endif hascompilerproc}
 

rtl/inc/dynarr.inc

@@ -43,14 +43,14 @@ function aligntoptr(p : pointer) : pointer;
   end;
 
 
-procedure fpc_dynarray_rangecheck(p : pointer;i : tdynarrayindex);[Public,Alias:'FPC_DYNARRAY_RANGECHECK']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_dynarray_rangecheck(p : pointer;i : tdynarrayindex);[Public,Alias:'FPC_DYNARRAY_RANGECHECK']; compilerproc;
   begin
      if not(assigned(p)) or (i<0) or (i>pdynarray(p-sizeof(tdynarray))^.high) then
        HandleErrorFrame(201,get_frame);
   end;
 
 
-function fpc_dynarray_length(p : pointer) : tdynarrayindex;[Public,Alias:'FPC_DYNARRAY_LENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_dynarray_length(p : pointer) : tdynarrayindex;[Public,Alias:'FPC_DYNARRAY_LENGTH']; compilerproc;
   begin
      if assigned(p) then
        fpc_dynarray_length:=pdynarray(p-sizeof(tdynarray))^.high+1
@@ -59,7 +59,7 @@ function fpc_dynarray_length(p : pointer) : tdynarrayindex;[Public,Alias:'FPC_DY
   end;
 
 
-function fpc_dynarray_high(p : pointer) : tdynarrayindex;[Public,Alias:'FPC_DYNARRAY_HIGH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_dynarray_high(p : pointer) : tdynarrayindex;[Public,Alias:'FPC_DYNARRAY_HIGH']; compilerproc;
   begin
      if assigned(p) then
        fpc_dynarray_high:=pdynarray(p-sizeof(tdynarray))^.high
@@ -94,7 +94,7 @@ procedure fpc_dynarray_clear_internal(p : pointer;ti : pointer);
   end;
 
 
-procedure fpc_dynarray_clear(var p : pointer;ti : pointer); [Public,Alias:'FPC_DYNARRAY_CLEAR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_dynarray_clear(var p : pointer;ti : pointer); [Public,Alias:'FPC_DYNARRAY_CLEAR']; compilerproc;
   var
      realp : pdynarray;
   begin
@@ -106,13 +106,11 @@ procedure fpc_dynarray_clear(var p : pointer;ti : pointer); [Public,Alias:'FPC_D
     p:=nil;
   end;
 
-{$ifdef hascompilerproc}
 { alias for internal use }
 Procedure fpc_dynarray_clear (var p : pointer;ti : pointer);[external name 'FPC_DYNARRAY_CLEAR'];
-{$endif hascompilerproc}
 
 
-procedure fpc_dynarray_decr_ref(var p : pointer;ti : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_DYNARRAY_DECR_REF']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_dynarray_decr_ref(var p : pointer;ti : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_DYNARRAY_DECR_REF']; compilerproc;
   var
      realp : pdynarray;
   begin
@@ -130,12 +128,10 @@ procedure fpc_dynarray_decr_ref(var p : pointer;ti : pointer);{$ifndef NOSAVEREG
      p := nil;
   end;
 
-{$ifdef hascompilerproc}
 { provide local access to dynarr_decr_ref for dynarr_setlength }
 procedure fpc_dynarray_decr_ref(var p : pointer;ti : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [external name 'FPC_DYNARRAY_DECR_REF'];
-{$endif}
 
-procedure fpc_dynarray_incr_ref(p : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_DYNARRAY_INCR_REF']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_dynarray_incr_ref(p : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_DYNARRAY_INCR_REF']; compilerproc;
   var
      realp : pdynarray;
   begin
@@ -149,17 +145,15 @@ procedure fpc_dynarray_incr_ref(p : pointer);{$ifndef NOSAVEREGISTERS}saveregist
      inclocked(realp^.refcount);
   end;
 
-{$ifdef hascompilerproc}
 { provide local access to dynarr_decr_ref for dynarr_setlength }
 procedure fpc_dynarray_incr_ref(p : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[external name 'FPC_DYNARRAY_INCR_REF'];
-{$endif}
 
 { provide local access to dynarr_setlength }
 procedure int_dynarray_setlength(var p : pointer;pti : pointer;
   dimcount : dword;dims : pdynarrayindex);[external name 'FPC_DYNARR_SETLENGTH'];
 
 procedure fpc_dynarray_setlength(var p : pointer;pti : pointer;
-  dimcount : dword;dims : pdynarrayindex);[Public,Alias:'FPC_DYNARR_SETLENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+  dimcount : dword;dims : pdynarrayindex);[Public,Alias:'FPC_DYNARR_SETLENGTH']; compilerproc;
 
   var
      i : tdynarrayindex;
@@ -298,13 +292,13 @@ function int_dynarray_copy(psrc : pointer;ti : pointer;
     lowidx,count:tdynarrayindex) : pointer;[external name 'FPC_DYNARR_COPY'];
 
 function fpc_dynarray_copy(psrc : pointer;ti : pointer;
-    lowidx,count:tdynarrayindex) : pointer;[Public,Alias:'FPC_DYNARR_COPY'];{$ifdef hascompilerproc} compilerproc; {$endif}
+    lowidx,count:tdynarrayindex) : pointer;[Public,Alias:'FPC_DYNARR_COPY'];compilerproc;
 {$else HASFUNCTIONCOPYDYNARR}
 procedure int_dynarray_copy(var pdest : pointer;psrc : pointer;ti : pointer;
     lowidx,count:tdynarrayindex);[external name 'FPC_DYNARR_COPY'];
 
 procedure fpc_dynarray_copy(var pdest : pointer;psrc : pointer;ti : pointer;
-    lowidx,count:tdynarrayindex);[Public,Alias:'FPC_DYNARR_COPY'];{$ifdef hascompilerproc} compilerproc; {$endif}
+    lowidx,count:tdynarrayindex);[Public,Alias:'FPC_DYNARR_COPY'];compilerproc;
 {$endif HASFUNCTIONCOPYDYNARR}
   var
     realpdest,

rtl/inc/except.inc

@@ -73,7 +73,7 @@ end;
 end;
 
 Function fpc_PushExceptAddr (Ft: Longint;_buf,_newaddr : pointer): PJmp_buf ;
-  [Public, Alias : 'FPC_PUSHEXCEPTADDR'];{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}{$ifdef hascompilerproc} compilerproc; {$endif}
+  [Public, Alias : 'FPC_PUSHEXCEPTADDR'];{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}compilerproc;
 
 var
   Buf : PJmp_buf;
@@ -101,7 +101,7 @@ end;
 
 
 Procedure fpc_PushExceptObj (Obj : TObject; AnAddr,AFrame : Pointer);
-  [Public, Alias : 'FPC_PUSHEXCEPTOBJECT'];{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}{$ifdef hascompilerproc} compilerproc; {$endif}
+  [Public, Alias : 'FPC_PUSHEXCEPTOBJECT'];{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}compilerproc;
 var
   Newobj : PExceptObject;
   framebufsize,
@@ -157,10 +157,8 @@ begin
   ExceptObjectStack^.frames:=frames;
 end;
 
-{$ifdef hascompilerproc}
 { make it avalable for local use }
 Procedure fpc_PushExceptObj (Obj : TObject; AnAddr,AFrame : Pointer); [external name 'FPC_PUSHEXCEPTOBJECT'];
-{$endif}
 
 
 Procedure DoUnHandledException;
@@ -172,7 +170,7 @@ begin
 end;
 
 
-Function fpc_Raiseexception (Obj : TObject; AnAddr,AFrame : Pointer) : TObject;[Public, Alias : 'FPC_RAISEEXCEPTION']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Raiseexception (Obj : TObject; AnAddr,AFrame : Pointer) : TObject;[Public, Alias : 'FPC_RAISEEXCEPTION']; compilerproc;
 begin
 {$ifdef excdebug}
   writeln ('In RaiseException');
@@ -188,7 +186,7 @@ begin
 end;
 
 
-Procedure fpc_PopAddrStack;[Public, Alias : 'FPC_POPADDRSTACK']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_PopAddrStack;[Public, Alias : 'FPC_POPADDRSTACK']; compilerproc;
 
 begin
 {$ifdef excdebug}
@@ -206,7 +204,7 @@ begin
 end;
 
 
-function fpc_PopObjectStack : TObject;[Public, Alias : 'FPC_POPOBJECTSTACK']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_PopObjectStack : TObject;[Public, Alias : 'FPC_POPOBJECTSTACK']; compilerproc;
 var
   hp : PExceptObject;
 begin
@@ -236,7 +234,7 @@ end;
 
 { this is for popping exception objects when a second exception is risen }
 { in an except/on                                                        }
-function fpc_PopSecondObjectStack : TObject;[Public, Alias : 'FPC_POPSECONDOBJECTSTACK']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_PopSecondObjectStack : TObject;[Public, Alias : 'FPC_POPSECONDOBJECTSTACK']; compilerproc;
 var
   hp : PExceptObject;
 begin
@@ -264,7 +262,7 @@ begin
     end;
 end;
 
-Procedure fpc_ReRaise;[Public, Alias : 'FPC_RERAISE']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_ReRaise;[Public, Alias : 'FPC_RERAISE']; compilerproc;
 begin
 {$ifdef excdebug}
   writeln ('In reraise');
@@ -276,7 +274,7 @@ begin
 end;
 
 
-Function fpc_Catches(Objtype : TClass) : TObject;[Public, Alias : 'FPC_CATCHES']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Catches(Objtype : TClass) : TObject;[Public, Alias : 'FPC_CATCHES']; compilerproc;
 var
   _Objtype : TExceptObjectClass;
 begin
@@ -302,7 +300,7 @@ begin
     end;
 end;
 
-Procedure fpc_DestroyException(o : TObject);[Public, Alias : 'FPC_DESTROYEXCEPTION']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_DestroyException(o : TObject);[Public, Alias : 'FPC_DESTROYEXCEPTION']; compilerproc;
 begin
   { with free we're on the really save side }
   o.Free;

rtl/inc/generic.inc

@@ -359,7 +359,7 @@ end;
 {$ifndef FPC_SYSTEM_HAS_FPC_HELP_CONSTRUCTOR}
 { Note: _vmt will be reset to -1 when memory is allocated,
   this is needed for fpc_help_fail }
-function fpc_help_constructor(_self:pointer;var _vmt:pointer;_vmt_pos:cardinal):pointer;[public,alias:'FPC_HELP_CONSTRUCTOR'];{$ifdef hascompilerproc}compilerproc;{$endif}
+function fpc_help_constructor(_self:pointer;var _vmt:pointer;_vmt_pos:cardinal):pointer;[public,alias:'FPC_HELP_CONSTRUCTOR'];compilerproc;
 type
   ppointer = ^pointer;
   pvmt = ^tvmt;
@@ -397,7 +397,7 @@ end;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_HELP_DESTRUCTOR}
 { Note: _self will not be reset, the compiler has to generate the reset }
-procedure fpc_help_destructor(_self,_vmt:pointer;vmt_pos:cardinal);[public,alias:'FPC_HELP_DESTRUCTOR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_help_destructor(_self,_vmt:pointer;vmt_pos:cardinal);[public,alias:'FPC_HELP_DESTRUCTOR'];  compilerproc;
 type
   ppointer = ^pointer;
   pvmt = ^tvmt;
@@ -457,7 +457,7 @@ end;
 {$ifndef NOCLASSHELPERS}
 
 {$ifndef FPC_SYSTEM_HAS_FPC_NEW_CLASS}
-function fpc_new_class(_self,_vmt:pointer):pointer;[public,alias:'FPC_NEW_CLASS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_new_class(_self,_vmt:pointer):pointer;[public,alias:'FPC_NEW_CLASS']; compilerproc;
 begin
   { Inherited call? }
   if _vmt=nil then
@@ -485,7 +485,7 @@ end;
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_CHECK_OBJECT}
-procedure fpc_check_object(_vmt : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias:'FPC_CHECK_OBJECT'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_check_object(_vmt : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias:'FPC_CHECK_OBJECT'];  compilerproc;
 type
   pvmt = ^tvmt;
   tvmt = packed record
@@ -506,7 +506,7 @@ end;
 { checks for a correct vmt pointer }
 { deeper check to see if the current object is }
 { really related to the true }
-procedure fpc_check_object_ext(vmt, expvmt : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias:'FPC_CHECK_OBJECT_EXT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_check_object_ext(vmt, expvmt : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias:'FPC_CHECK_OBJECT_EXT']; compilerproc;
 type
   pvmt = ^tvmt;
   tvmt = packed record
@@ -534,7 +534,7 @@ end;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_ASSIGN}
 
-function fpc_shortstr_to_shortstr(len:longint;const sstr:shortstring): shortstring;[public,alias:'FPC_SHORTSTR_TO_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_shortstr_to_shortstr(len:longint;const sstr:shortstring): shortstring;[public,alias:'FPC_SHORTSTR_TO_SHORTSTR']; compilerproc;
 var
   slen : byte;
 begin
@@ -564,7 +564,7 @@ end;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_CONCAT}
 
-function fpc_shortstr_concat(const s1,s2:shortstring): shortstring;[public,alias:'FPC_SHORTSTR_CONCAT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_shortstr_concat(const s1,s2:shortstring): shortstring;[public,alias:'FPC_SHORTSTR_CONCAT']; compilerproc;
 var
   s1l, s2l : byte;
 begin
@@ -580,7 +580,7 @@ end;
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_APPEND_SHORTSTR}
-procedure fpc_shortstr_append_shortstr(var s1:shortstring;const s2:shortstring);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_shortstr_append_shortstr(var s1:shortstring;const s2:shortstring);compilerproc;
     [public,alias:'FPC_SHORTSTR_APPEND_SHORTSTR'];
 var
   s1l, s2l : byte;
@@ -596,7 +596,7 @@ end;
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_COMPARE}
-function fpc_shortstr_compare(const left,right:shortstring) : longint;[public,alias:'FPC_SHORTSTR_COMPARE']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_shortstr_compare(const left,right:shortstring) : longint;[public,alias:'FPC_SHORTSTR_COMPARE']; compilerproc;
 var
    s1,s2,max,i : byte;
    d : longint;
@@ -627,7 +627,7 @@ end;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_PCHAR_TO_SHORTSTR}
 
-function fpc_pchar_to_shortstr(p:pchar):shortstring;[public,alias:'FPC_PCHAR_TO_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_pchar_to_shortstr(p:pchar):shortstring;[public,alias:'FPC_PCHAR_TO_SHORTSTR']; compilerproc;
 var
   l : longint;
   s: shortstring;
@@ -649,20 +649,13 @@ end;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_CHARARRAY_TO_SHORTSTR}
 
-{$ifdef hascompilerproc}
 function fpc_chararray_to_shortstr(const arr: array of char):shortstring;[public,alias:'FPC_CHARARRAY_TO_SHORTSTR']; compilerproc;
 var
   l: longint;
-{$else hascompilerproc}
-function fpc_chararray_to_shortstr(arr:pchar; l : longint):shortstring;[public,alias:'FPC_CHARARRAY_TO_SHORTSTR'];
-var
-{$endif hascompilerproc}
  index: longint;
  len: byte;
 begin
-{$ifdef hascompilerproc}
   l := high(arr)+1;
-{$endif hascompilerproc}
   if l>=256 then
     l:=255
   else if l<0 then
@@ -678,7 +671,6 @@ end;
 
 {$endif ndef FPC_SYSTEM_HAS_FPC_CHARARRAY_TO_SHORTSTR}
 
-{$ifdef hascompilerproc}
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SHORTSTR_TO_CHARARRAY}
 
@@ -699,56 +691,9 @@ end;
 
 {$endif FPC_SYSTEM_HAS_FPC_SHORTSTR_TO_CHARARRAY}
 
-{$else hascompilerproc}
-
-{$ifopt r+}
-{$define rangeon}
-{$r-}
-{$endif}
-
-{$ifndef FPC_SYSTEM_HAS_FPC_STR_TO_CHARARRAY}
-procedure fpc_str_to_chararray(strtyp, arraysize: longint; src,dest: pchar);[public,alias:'FPC_STR_TO_CHARARRAY'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-type
-  plongint = ^longint;
-var
-  len: longint;
-begin
-  case strtyp of
-    { shortstring }
-    0:
-      begin
-        len := byte(src[0]);
-        inc(src);
-      end;
-{$ifdef SUPPORT_ANSISTRING}
-    { ansistring}
-    1: len := length(ansistring(pointer(src)));
-{$endif SUPPORT_ANSISTRING}
-    { longstring }
-    2:;
-    { widestring }
-    3: ;
-  end;
-  if len > arraysize then
-    len := arraysize;
-  { make sure we don't dereference src if it can be nil (JM) }
-  if len > 0 then
-    move(src^,dest^,len);
-  fillchar(dest[len],arraysize-len,0);
-end;
-
-{$endif FPC_SYSTEM_HAS_FPC_STR_TO_CHARARRAY}
-
-{$ifdef rangeon}
-{$r+}
-{undef rangeon}
-{$endif rangeon}
-
-{$endif hascompilerproc}
-
 {$ifndef FPC_SYSTEM_HAS_FPC_PCHAR_LENGTH}
 
-function fpc_pchar_length(p:pchar):longint;[public,alias:'FPC_PCHAR_LENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_pchar_length(p:pchar):longint;[public,alias:'FPC_PCHAR_LENGTH']; compilerproc;
 var i : longint;
 begin
   i:=0;
@@ -760,7 +705,7 @@ end;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_PWIDECHAR_LENGTH}
 
-function fpc_pwidechar_length(p:pwidechar):longint;[public,alias:'FPC_PWIDECHAR_LENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_pwidechar_length(p:pwidechar):longint;[public,alias:'FPC_PWIDECHAR_LENGTH']; compilerproc;
 var i : longint;
 begin
   i:=0;
@@ -812,7 +757,7 @@ function count_leading_zeros_32bit(l : longint) : longint;
 
 
 {$ifndef FPC_SYSTEM_HAS_DIV_DWORD}
-function fpc_div_dword(n,z : dword) : dword; [public,alias: 'FPC_DIV_DWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_div_dword(n,z : dword) : dword; [public,alias: 'FPC_DIV_DWORD']; compilerproc;
   var
      shift,lzz,lzn : longint;
   begin
@@ -842,7 +787,7 @@ function fpc_div_dword(n,z : dword) : dword; [public,alias: 'FPC_DIV_DWORD']; {$
 
 
 {$ifndef FPC_SYSTEM_HAS_MOD_DWORD}
-function fpc_mod_dword(n,z : dword) : dword; [public,alias: 'FPC_MOD_DWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_mod_dword(n,z : dword) : dword; [public,alias: 'FPC_MOD_DWORD']; compilerproc;
   var
      shift,lzz,lzn : longint;
   begin
@@ -873,7 +818,7 @@ function fpc_mod_dword(n,z : dword) : dword; [public,alias: 'FPC_MOD_DWORD']; {$
 
 
 {$ifndef FPC_SYSTEM_HAS_DIV_LONGINT}
-function fpc_div_longint(n,z : longint) : longint; [public,alias: 'FPC_DIV_LONGINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_div_longint(n,z : longint) : longint; [public,alias: 'FPC_DIV_LONGINT']; compilerproc;
   var
      sign : boolean;
      d1,d2 : dword;
@@ -906,7 +851,7 @@ function fpc_div_longint(n,z : longint) : longint; [public,alias: 'FPC_DIV_LONGI
 
 
 {$ifndef FPC_SYSTEM_HAS_MOD_LONGINT}
-function fpc_mod_longint(n,z : longint) : longint; [public,alias: 'FPC_MOD_LONGINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_mod_longint(n,z : longint) : longint; [public,alias: 'FPC_MOD_LONGINT']; compilerproc;
   var
      signed : boolean;
      r,nq,zq : dword;

rtl/inc/genmath.inc

@@ -421,9 +421,7 @@ type
 {$endif}
 
 {$ifndef INTERNCONSTINTF}
-  {$ifdef hascompilerproc}
     function fpc_abs_real(d:Real):Real;compilerproc; external name 'FPC_ABS_REAL';
-  {$endif hascompilerproc}
 {$endif}
 
 {$endif not FPC_SYSTEM_HAS_ABS}
@@ -567,9 +565,7 @@ type
   {$ifdef INTERNCONSTINTF}
     function fpc_sqrt_real(d:Real):Real;compilerproc;
   {$else}
-    {$ifdef hascompilerproc}
        function fpc_sqrt_real(d:Real):Real;compilerproc; external name 'FPC_SQRT_REAL';
-    {$endif hascompilerproc}
     function sqrt(d:Real):Real;[internconst:fpc_in_const_sqrt];[public, alias: 'FPC_SQRT_REAL'];
   {$endif}
     {*****************************************************************}
@@ -714,12 +710,8 @@ type
   {$ifdef INTERNCONSTINTF}
     function fpc_round_real(d : Real) : int64;compilerproc;
   {$else}
-    {$ifdef hascompilerproc}
       function round(d : Real) : int64;{$ifndef INTERNCONSTINTF}[internconst:fpc_in_const_round];{$endif} external name 'FPC_ROUND';
-      function fpc_round(d : Real) : int64;[public, alias:'FPC_ROUND'];{$ifdef hascompilerproc}compilerproc;{$endif hascompilerproc}
-   {$else}
-      function round(d : Real) : int64;{$ifndef INTERNCONSTINTF}[internconst:fpc_in_const_round];{$endif}
-   {$endif hascompilerproc}
+      function fpc_round(d : Real) : int64;[public, alias:'FPC_ROUND'];compilerproc;
  {$endif}
      var
       fr: Real;

rtl/inc/genset.inc

@@ -18,7 +18,7 @@
  { THIS DEPENDS ON THE ENDIAN OF THE ARCHITECTURE!
    Not anymore PM}
 
-function fpc_set_load_small(l: fpc_small_set): fpc_normal_set; [public,alias:'FPC_SET_LOAD_SMALL']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_set_load_small(l: fpc_small_set): fpc_normal_set; [public,alias:'FPC_SET_LOAD_SMALL']; compilerproc;
  {
   load a normal set p from a smallset l
  }
@@ -30,7 +30,7 @@ function fpc_set_load_small(l: fpc_small_set): fpc_normal_set; [public,alias:'FP
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_CREATE_ELEMENT}
-function fpc_set_create_element(b : byte): fpc_normal_set;[public,alias:'FPC_SET_CREATE_ELEMENT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_set_create_element(b : byte): fpc_normal_set;[public,alias:'FPC_SET_CREATE_ELEMENT']; compilerproc;
  {
   create a new set in p from an element b
  }
@@ -42,7 +42,6 @@ function fpc_set_create_element(b : byte): fpc_normal_set;[public,alias:'FPC_SET
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_SET_BYTE}
 
-{$ifdef hascompilerproc}
  function fpc_set_set_byte(const source: fpc_normal_set; b : byte): fpc_normal_set; compilerproc;
  {
   add the element b to the set "source"
@@ -55,25 +54,11 @@ function fpc_set_create_element(b : byte): fpc_normal_set;[public,alias:'FPC_SET
     c := (1 shl (b mod 32)) or c;
     fpc_set_set_byte[b div 32] := c;
   end;
-{$else hascompilerproc}
- procedure do_set_byte(p : pointer;b : byte);[public,alias:'FPC_SET_SET_BYTE'];
- {
-  add the element b to the set pointed by p
- }
-  var
-   c: longint;
-  begin
-    c := fpc_normal_set(p^)[b div 32];
-    c := (1 shl (b mod 32)) or c;
-    fpc_normal_set(p^)[b div 32] := c;
-  end;
-{$endif hascompilerproc}
 {$endif FPC_SYSTEM_HAS_FPC_SET_SET_BYTE}
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_UNSET_BYTE}
 
-{$ifdef hascompilerproc}
 function fpc_set_unset_byte(const source: fpc_normal_set; b : byte): fpc_normal_set; compilerproc;
  {
    suppresses the element b to the set pointed by p
@@ -87,25 +72,10 @@ function fpc_set_unset_byte(const source: fpc_normal_set; b : byte): fpc_normal_
     c := c and not (1 shl (b mod 32));
     fpc_set_unset_byte[b div 32] := c;
   end;
-{$else hascompilerproc}
-procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'];
- {
-   suppresses the element b to the set pointed by p
-   used for exclude(set,element)
- }
-  var
-   c: longint;
-  begin
-    c := fpc_normal_set(p^)[b div 32];
-    c := c and not (1 shl (b mod 32));
-    fpc_normal_set(p^)[b div 32] := c;
-  end;
-{$endif hascompilerproc}
 {$endif FPC_SYSTEM_HAS_FPC_SET_UNSET_BYTE}
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_SET_RANGE}
-{$ifdef hascompilerproc}
  function fpc_set_set_range(const orgset: fpc_normal_set; l,h : byte): fpc_normal_set; compilerproc;
  {
    adds the range [l..h] to the set orgset
@@ -122,29 +92,12 @@ procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'
         fpc_set_set_range[i div 32] := c;
       end;
   end;
-{$else hascompilerproc}
- procedure do_set_range(p : pointer;l,h : byte);[public,alias:'FPC_SET_SET_RANGE'];
- {
-  bad implementation, but it's very seldom used
- }
-  var
-   i: integer;
-   c: longint;
-  begin
-    for i:=l to h do
-      begin
-        c := fpc_normal_set(p^)[i div 32];
-        c := (1 shl (i mod 32)) or c;
-        fpc_normal_set(p^)[i div 32] := c;
-      end;
-  end;
-{$endif hascompilerproc}
 {$endif ndef FPC_SYSTEM_HAS_FPC_SET_SET_RANGE}
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_IN_BYTE}
 
- function fpc_set_in_byte(const p: fpc_normal_set; b: byte): boolean; [public,alias:'FPC_SET_IN_BYTE']; {$ifdef hascompilerproc} compilerproc; {$else} {$ifndef NOSAVEREGISTERS}saveregisters;{$endif} {$endif}
+ function fpc_set_in_byte(const p: fpc_normal_set; b: byte): boolean; [public,alias:'FPC_SET_IN_BYTE']; compilerproc; 
  {
    tests if the element b is in the set p the carryflag is set if it present
  }
@@ -155,13 +108,9 @@ procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_ADD_SETS}
-{$ifdef hascompilerproc}
  function fpc_set_add_sets(const set1,set2: fpc_normal_set): fpc_normal_set;[public,alias:'FPC_SET_ADD_SETS']; compilerproc;
  var
    dest: fpc_normal_set absolute fpc_set_add_sets;
-{$else hascompilerproc}
- procedure do_add_sets(const set1,set2: fpc_normal_Set; var dest : fpc_normal_set);[public,alias:'FPC_SET_ADD_SETS'];
-{$endif hascompilerproc}
  {
    adds set1 and set2 into set dest
  }
@@ -175,13 +124,9 @@ procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_MUL_SETS}
-{$ifdef hascompilerproc}
  function fpc_set_mul_sets(const set1,set2: fpc_normal_set): fpc_normal_set;[public,alias:'FPC_SET_MUL_SETS']; compilerproc;
  var
    dest: fpc_normal_set absolute fpc_set_mul_sets;
-{$else hascompilerproc}
- procedure do_mul_sets(const set1,set2: fpc_normal_set; var dest: fpc_normal_set);[public,alias:'FPC_SET_MUL_SETS'];
-{$endif hascompilerproc}
  {
    multiplies (takes common elements of) set1 and set2 result put in dest
  }
@@ -195,13 +140,9 @@ procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_SUB_SETS}
-{$ifdef hascompilerproc}
  function fpc_set_sub_sets(const set1,set2: fpc_normal_set): fpc_normal_set;[public,alias:'FPC_SET_SUB_SETS']; compilerproc;
  var
    dest: fpc_normal_set absolute fpc_set_sub_sets;
-{$else hascompilerproc}
- procedure do_sub_sets(const set1,set2: fpc_normal_set; var dest: fpc_normal_set);[public,alias:'FPC_SET_SUB_SETS'];
-{$endif hascompilerproc}
  {
   computes the diff from set1 to set2 result in dest
  }
@@ -215,13 +156,9 @@ procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_SYMDIF_SETS}
-{$ifdef hascompilerproc}
  function fpc_set_symdif_sets(const set1,set2: fpc_normal_set): fpc_normal_set;[public,alias:'FPC_SET_SYMDIF_SETS']; compilerproc;
  var
    dest: fpc_normal_set absolute fpc_set_symdif_sets;
-{$else hascompilerproc}
- procedure do_symdif_sets(const set1,set2: fpc_normal_set; var dest: fpc_normal_set);[public,alias:'FPC_SET_SYMDIF_SETS'];
-{$endif hascompilerproc}
  {
    computes the symetric diff from set1 to set2 result in dest
  }
@@ -234,7 +171,7 @@ procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'
 {$endif}
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_COMP_SETS}
- function fpc_set_comp_sets(const set1,set2 : fpc_normal_set):boolean;[public,alias:'FPC_SET_COMP_SETS'];{$ifdef hascompilerproc} compilerproc; {$else} {$ifndef NOSAVEREGISTERS}saveregisters;{$endif} {$endif}
+ function fpc_set_comp_sets(const set1,set2 : fpc_normal_set):boolean;[public,alias:'FPC_SET_COMP_SETS'];compilerproc;
  {
   compares set1 and set2 zeroflag is set if they are equal
  }
@@ -252,7 +189,7 @@ procedure do_unset_byte(p : pointer;b : byte);[public,alias:'FPC_SET_UNSET_BYTE'
 
 
 {$ifndef FPC_SYSTEM_HAS_FPC_SET_CONTAINS_SET}
- function fpc_set_contains_sets(const set1,set2 : fpc_normal_set):boolean;[public,alias:'FPC_SET_CONTAINS_SETS'];{$ifdef hascompilerproc} compilerproc; {$else} saveregisters; {$endif}
+ function fpc_set_contains_sets(const set1,set2 : fpc_normal_set):boolean;[public,alias:'FPC_SET_CONTAINS_SETS'];compilerproc;
  {
   on exit, zero flag is set if set1 <= set2 (set2 contains set1)
  }

rtl/inc/int64.inc

@@ -33,7 +33,7 @@
 {$ifdef  FPC_INCLUDE_SOFTWARE_SHIFT_INT64}
 
 {$ifndef FPC_SYSTEM_HAS_SHL_QWORD}
-    function fpc_shl_qword(value,shift : qword) : qword; [public,alias: 'FPC_SHL_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_shl_qword(value,shift : qword) : qword; [public,alias: 'FPC_SHL_QWORD']; compilerproc;
       begin
         shift:=shift and 63;
         if shift=0 then
@@ -53,7 +53,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_SHR_QWORD}
-   function fpc_shr_qword(value,shift : qword) : qword; [public,alias: 'FPC_SHR_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+   function fpc_shr_qword(value,shift : qword) : qword; [public,alias: 'FPC_SHR_QWORD']; compilerproc;
       begin
         shift:=shift and 63;
         if shift=0 then
@@ -73,7 +73,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_SHL_INT64}
-    function fpc_shl_int64(value,shift : int64) : int64; [public,alias: 'FPC_SHL_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_shl_int64(value,shift : int64) : int64; [public,alias: 'FPC_SHL_INT64']; compilerproc;
       begin
         shift:=shift and 63;
         if shift=0 then
@@ -93,7 +93,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_SHR_INT64}
-    function fpc_shr_int64(value,shift : int64) : int64; [public,alias: 'FPC_SHR_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_shr_int64(value,shift : int64) : int64; [public,alias: 'FPC_SHR_INT64']; compilerproc;
       begin
         shift:=shift and 63;
         if shift=0 then
@@ -145,7 +145,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_DIV_QWORD}
-    function fpc_div_qword(n,z : qword) : qword;[public,alias: 'FPC_DIV_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_div_qword(n,z : qword) : qword;[public,alias: 'FPC_DIV_QWORD']; compilerproc;
 
       var
          shift,lzz,lzn : longint;
@@ -177,7 +177,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_MOD_QWORD}
-    function fpc_mod_qword(n,z : qword) : qword;[public,alias: 'FPC_MOD_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mod_qword(n,z : qword) : qword;[public,alias: 'FPC_MOD_QWORD']; compilerproc;
 
       var
          shift,lzz,lzn : longint;
@@ -210,7 +210,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_DIV_INT64}
-    function fpc_div_int64(n,z : int64) : int64;[public,alias: 'FPC_DIV_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_div_int64(n,z : int64) : int64;[public,alias: 'FPC_DIV_INT64']; compilerproc;
 
       var
          sign : boolean;
@@ -248,7 +248,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_MOD_INT64}
-    function fpc_mod_int64(n,z : int64) : int64;[public,alias: 'FPC_MOD_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mod_int64(n,z : int64) : int64;[public,alias: 'FPC_MOD_INT64']; compilerproc;
 
       var
          signed : boolean;
@@ -284,7 +284,7 @@
     { multiplies two qwords
       the longbool for checkoverflow avoids a misaligned stack
     }
-    function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;[public,alias: 'FPC_MUL_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;[public,alias: 'FPC_MUL_QWORD']; compilerproc;
 
       var
          _f1,bitpos : qword;
@@ -318,7 +318,7 @@
 
 
 {$ifndef FPC_SYSTEM_HAS_MUL_INT64}
-    function fpc_mul_int64(f1,f2 : int64;checkoverflow : longbool) : int64;[public,alias: 'FPC_MUL_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mul_int64(f1,f2 : int64;checkoverflow : longbool) : int64;[public,alias: 'FPC_MUL_INT64']; compilerproc;
 
       var
          sign : boolean;

rtl/inc/objpas.inc

@@ -18,7 +18,7 @@
 ****************************************************************************}
 
     { the reverse order of the parameters make code generation easier }
-    function fpc_do_is(aclass : tclass;aobject : tobject) : boolean;[public,alias: 'FPC_DO_IS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_do_is(aclass : tclass;aobject : tobject) : boolean;[public,alias: 'FPC_DO_IS']; compilerproc;
       begin
          fpc_do_is:=assigned(aobject) and assigned(aclass) and
            aobject.inheritsfrom(aclass);
@@ -26,7 +26,7 @@
 
 
     { the reverse order of the parameters make code generation easier }
-    function fpc_do_as(aclass : tclass;aobject : tobject): tobject;[public,alias: 'FPC_DO_AS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_do_as(aclass : tclass;aobject : tobject): tobject;[public,alias: 'FPC_DO_AS']; compilerproc;
       begin
          if assigned(aobject) and not(aobject.inheritsfrom(aclass)) then
            handleerrorframe(219,get_frame);
@@ -34,31 +34,27 @@
       end;
 
     { interface helpers }
-    procedure fpc_intf_decr_ref(var i: pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias: 'FPC_INTF_DECR_REF']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    procedure fpc_intf_decr_ref(var i: pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias: 'FPC_INTF_DECR_REF']; compilerproc;
       begin
         if assigned(i) then
           IUnknown(i)._Release;
         i:=nil;
       end;
 
-    {$ifdef hascompilerproc}
     { local declaration for intf_decr_ref for local access }
     procedure intf_decr_ref(var i: pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [external name 'FPC_INTF_DECR_REF'];
-    {$endif hascompilerproc}
 
 
-    procedure fpc_intf_incr_ref(i: pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias: 'FPC_INTF_INCR_REF']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    procedure fpc_intf_incr_ref(i: pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias: 'FPC_INTF_INCR_REF']; compilerproc;
       begin
          if assigned(i) then
            IUnknown(i)._AddRef;
       end;
 
-    {$ifdef hascompilerproc}
     { local declaration of intf_incr_ref for local access }
     procedure intf_incr_ref(i: pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [external name 'FPC_INTF_INCR_REF'];
-    {$endif hascompilerproc}
 
-    procedure fpc_intf_assign(var D: pointer; const S: pointer);[public,alias: 'FPC_INTF_ASSIGN']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    procedure fpc_intf_assign(var D: pointer; const S: pointer);[public,alias: 'FPC_INTF_ASSIGN']; compilerproc;
       begin
          if assigned(S) then
            IUnknown(S)._AddRef;
@@ -67,7 +63,7 @@
          D:=S;
       end;
 
-    function fpc_intf_as(const S: pointer; const iid: TGUID): pointer;[public,alias: 'FPC_INTF_AS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_intf_as(const S: pointer; const iid: TGUID): pointer;[public,alias: 'FPC_INTF_AS']; compilerproc;
 
       var
         tmpi: pointer; // _AddRef before _Release
@@ -83,7 +79,7 @@
       end;
 
 
-    function fpc_class_as_intf(const S: pointer; const iid: TGUID): pointer;[public,alias: 'FPC_CLASS_AS_INTF']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_class_as_intf(const S: pointer; const iid: TGUID): pointer;[public,alias: 'FPC_CLASS_AS_INTF']; compilerproc;
 
       var
         tmpi: pointer; // _AddRef before _Release

rtl/inc/rtti.inc

@@ -126,7 +126,7 @@ end;
 
 
 
-Procedure fpc_Initialize (Data,TypeInfo : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias : 'FPC_INITIALIZE'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Initialize (Data,TypeInfo : pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias : 'FPC_INITIALIZE'];  compilerproc;
 begin
   case PByte(TypeInfo)^ of
     tkAstring,tkWstring,tkInterface,tkDynArray:
@@ -142,7 +142,7 @@ begin
 end;
 
 
-Procedure fpc_finalize (Data,TypeInfo: Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias : 'FPC_FINALIZE'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_finalize (Data,TypeInfo: Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias : 'FPC_FINALIZE'];  compilerproc;
 begin
   case PByte(TypeInfo)^ of
     tkAstring :
@@ -173,7 +173,7 @@ begin
 end;
 
 
-Procedure fpc_Addref (Data,TypeInfo : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [Public,alias : 'FPC_ADDREF'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Addref (Data,TypeInfo : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [Public,alias : 'FPC_ADDREF'];  compilerproc;
 begin
   case PByte(TypeInfo)^ of
     tkAstring :
@@ -199,7 +199,7 @@ end;
 { we use another name else the compiler gets puzzled because of the wrong forward def }
 procedure fpc_systemDecRef (Data, TypeInfo : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[external name 'FPC_DECREF'];
 
-Procedure fpc_DecRef (Data, TypeInfo : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,alias : 'FPC_DECREF'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_DecRef (Data, TypeInfo : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,alias : 'FPC_DECREF'];  compilerproc;
 begin
   case PByte(TypeInfo)^ of
     { see AddRef for comment about below construct (JM) }
@@ -222,7 +222,7 @@ begin
 end;
 
 
-procedure fpc_finalize_array(data,typeinfo : pointer;count,size : longint); [Public,Alias:'FPC_FINALIZEARRAY'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_finalize_array(data,typeinfo : pointer;count,size : longint); [Public,Alias:'FPC_FINALIZEARRAY'];  compilerproc;
   var
      i : longint;
   begin

rtl/inc/softfpu.pp

@@ -38,10 +38,6 @@ unit softfpu;
 }
 {$Q-}
 
-{$ifdef fpc}
-{$define hascompilerproc}
-{$endif}
-
 {$ifdef fpc}
 {$goto on}
 {$endif}
@@ -106,7 +102,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_lt(a: float64;b: float64): flag; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float64_lt(a: float64;b: float64): flag; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the double-precision floating-point value `a' is less than
@@ -115,7 +111,7 @@ is performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_le(a: float64;b: float64): flag; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float64_le(a: float64;b: float64): flag; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the double-precision floating-point value `a' is equal to
@@ -123,7 +119,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_eq(a: float64;b: float64): flag; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float64_eq(a: float64;b: float64): flag; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the square root of the double-precision floating-point value `a'.
@@ -131,7 +127,7 @@ The operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_sqrt( a: float64; var out: float64 ); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float64_sqrt( a: float64; var out: float64 ); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the remainder of the double-precision floating-point value `a'
@@ -139,7 +135,7 @@ with respect to the corresponding value `b'.  The operation is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_rem(a: float64; b : float64; var out: float64); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float64_rem(a: float64; b : float64; var out: float64); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of dividing the double-precision floating-point value `a'
@@ -147,7 +143,7 @@ by the corresponding value `b'.  The operation is performed according to the
 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_div(a: float64; b : float64 ; var out: float64 ); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float64_div(a: float64; b : float64 ; var out: float64 ); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of multiplying the double-precision floating-point values
@@ -155,7 +151,7 @@ Returns the result of multiplying the double-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_mul( a: float64; b:float64; Var out: float64); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float64_mul( a: float64; b:float64; Var out: float64); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of subtracting the double-precision floating-point values
@@ -163,7 +159,7 @@ Returns the result of subtracting the double-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_sub(a: float64; b : float64; var out: float64); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float64_sub(a: float64; b : float64; var out: float64); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of adding the double-precision floating-point values `a'
@@ -171,7 +167,7 @@ and `b'.  The operation is performed according to the IEC/IEEE Standard for
 Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_add( a: float64; b : float64; Var out : float64); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float64_add( a: float64; b : float64; Var out : float64); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Rounds the double-precision floating-point value `a' to an integer,
@@ -180,7 +176,7 @@ operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_round_to_int(a: float64; var out: float64 ); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float64_round_to_int(a: float64; var out: float64 ); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the double-precision floating-point value
@@ -189,7 +185,7 @@ performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_float32(a: float64 ): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float64_to_float32(a: float64 ): float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the double-precision floating-point value
@@ -201,7 +197,7 @@ the conversion overflows, the largest integer with the same sign as `a' is
 returned.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_int32_round_to_zero(a: float64 ): int32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float64_to_int32_round_to_zero(a: float64 ): int32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the double-precision floating-point value
@@ -213,7 +209,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_int32(a: float64): int32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float64_to_int32(a: float64): int32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the single-precision floating-point value `a' is less than
@@ -221,7 +217,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_lt( a:float32 ; b : float32): flag; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_lt( a:float32 ; b : float32): flag; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the single-precision floating-point value `a' is less than
@@ -230,7 +226,7 @@ is performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_le( a: float32; b : float32 ):flag; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_le( a: float32; b : float32 ):flag; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns 1 if the single-precision floating-point value `a' is equal to
@@ -238,7 +234,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_eq( a:float32; b:float32): flag; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_eq( a:float32; b:float32): flag; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the square root of the single-precision floating-point value `a'.
@@ -246,7 +242,7 @@ The operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sqrt(a: float32 ): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_sqrt(a: float32 ): float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the remainder of the single-precision floating-point value `a'
@@ -254,7 +250,7 @@ with respect to the corresponding value `b'.  The operation is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_rem(a: float32; b: float32 ):float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_rem(a: float32; b: float32 ):float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of dividing the single-precision floating-point value `a'
@@ -262,7 +258,7 @@ by the corresponding value `b'.  The operation is performed according to the
 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_div(a: float32;b: float32 ): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_div(a: float32;b: float32 ): float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of multiplying the single-precision floating-point values
@@ -270,7 +266,7 @@ Returns the result of multiplying the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_mul(a: float32; b: float32 ) : float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_mul(a: float32; b: float32 ) : float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of subtracting the single-precision floating-point values
@@ -278,7 +274,7 @@ Returns the result of subtracting the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sub( a: float32 ; b:float32 ): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_sub( a: float32 ; b:float32 ): float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of adding the single-precision floating-point values `a'
@@ -286,7 +282,7 @@ and `b'.  The operation is performed according to the IEC/IEEE Standard for
 Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_add( a: float32; b:float32 ): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_add( a: float32; b:float32 ): float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Rounds the single-precision floating-point value `a' to an integer,
@@ -295,7 +291,7 @@ operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_round_to_int( a: float32): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_round_to_int( a: float32): float32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the single-precision floating-point value
@@ -304,7 +300,7 @@ performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float32_to_float64( a : float32; var out: Float64); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure float32_to_float64( a : float32; var out: Float64); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the single-precision floating-point value
@@ -316,7 +312,7 @@ the conversion overflows, the largest integer with the same sign as `a' is
 returned.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_int32_round_to_zero( a: Float32 ): int32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_to_int32_round_to_zero( a: Float32 ): int32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the single-precision floating-point value
@@ -328,7 +324,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_int32( a : float32) : int32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function float32_to_int32( a : float32) : int32; compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the 32-bit two's complement integer `a' to
@@ -336,7 +332,7 @@ the double-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure int32_to_float64( a: int32; var c: float64 ); {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure int32_to_float64( a: int32; var c: float64 ); compilerproc;
 {*
 -------------------------------------------------------------------------------
 Returns the result of converting the 32-bit two's complement integer `a' to
@@ -344,21 +340,21 @@ the single-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function int32_to_float32( a: int32): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function int32_to_float32( a: int32): float32; compilerproc;
 
 {*----------------------------------------------------------------------------
 | Returns the result of converting the 64-bit two's complement integer `a'
 | to the double-precision floating-point format.  The conversion is performed
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
-function int64_to_float64( a: int64 ): float64; {$ifdef hascompilerproc} compilerproc; {$endif}
+function int64_to_float64( a: int64 ): float64; compilerproc;
 
 {*----------------------------------------------------------------------------
 | Returns the result of converting the 64-bit two's complement integer `a'
 | to the single-precision floating-point format.  The conversion is performed
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
-function int64_to_float32( a: int64 ): float32; {$ifdef hascompilerproc} compilerproc; {$endif}
+function int64_to_float32( a: int64 ): float32; compilerproc;
 
 
 CONST
@@ -2077,7 +2073,7 @@ the single-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function int32_to_float32( a: int32): float32; {$ifdef fpc}[public,Alias:'INT32_TO_FLOAT32'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function int32_to_float32( a: int32): float32; {$ifdef fpc}[public,Alias:'INT32_TO_FLOAT32'];compilerproc;{$endif}
  Var
   zSign : Flag;
  Begin
@@ -2107,7 +2103,7 @@ the double-precision floating-point format.  The conversion is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure int32_to_float64( a: int32; var c: float64 );{$ifdef fpc} [public,Alias:'INT32_TO_FLOAT64'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Procedure int32_to_float64( a: int32; var c: float64 );{$ifdef fpc} [public,Alias:'INT32_TO_FLOAT64'];compilerproc;{$endif}
   var
     zSign : flag;
     absA : bits32;
@@ -2149,7 +2145,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float32_to_int32( a : float32) : int32;{$ifdef fpc} [public,Alias:'FLOAT32_TO_INT32'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_to_int32( a : float32) : int32;{$ifdef fpc} [public,Alias:'FLOAT32_TO_INT32'];compilerproc;{$endif}
   Var
     aSign: flag;
     aExp, shiftCount: int16;
@@ -2238,7 +2234,7 @@ returned.
 -------------------------------------------------------------------------------
 *}
 Function float32_to_int32_round_to_zero( a: Float32 ): int32;
- {$ifdef fpc}[public,Alias:'FLOAT32_TO_INT32_ROUND_TO_ZERO'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+ {$ifdef fpc}[public,Alias:'FLOAT32_TO_INT32_ROUND_TO_ZERO'];compilerproc;{$endif}
  Var
     aSign : flag;
     aExp, shiftCount : int16;
@@ -2292,7 +2288,7 @@ Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Procedure float32_to_float64( a : float32; var out: Float64);
-{$ifdef fpc}[public,Alias:'FLOAT32_TO_FLOAT64'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT32_TO_FLOAT64'];compilerproc;{$endif}
   Var
     aSign : flag;
     aExp : int16;
@@ -2336,7 +2332,7 @@ Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float32_round_to_int( a: float32): float32;
-{$ifdef fpc}[public,Alias:'FLOAT32_ROUND_TO_INT'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT32_ROUND_TO_INT'];compilerproc;{$endif}
   Var
     aSign: flag;
     aExp: int16;
@@ -2634,7 +2630,7 @@ and `b'.  The operation is performed according to the IEC/IEEE Standard for
 Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_add( a: float32; b:float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_ADD'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_add( a: float32; b:float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_ADD'];compilerproc;{$endif}
   Var
     aSign, bSign: Flag;
   Begin
@@ -2657,7 +2653,7 @@ Returns the result of subtracting the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sub( a: float32 ; b:float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_SUB'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_sub( a: float32 ; b:float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_SUB'];compilerproc;{$endif}
   Var
     aSign, bSign: flag;
   Begin
@@ -2680,7 +2676,7 @@ Returns the result of multiplying the single-precision floating-point values
 for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_mul(a: float32; b: float32 ) : float32;{$ifdef fpc} [public,Alias:'FLOAT32_MUL'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_mul(a: float32; b: float32 ) : float32;{$ifdef fpc} [public,Alias:'FLOAT32_MUL'];compilerproc;{$endif}
 
   Var
     aSign, bSign, zSign: flag;
@@ -2763,7 +2759,7 @@ by the corresponding value `b'.  The operation is performed according to the
 IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_div(a: float32;b: float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_DIV'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_div(a: float32;b: float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_DIV'];compilerproc;{$endif}
   Var
     aSign, bSign, zSign: flag;
     aExp, bExp, zExp: int16;
@@ -2862,7 +2858,7 @@ with respect to the corresponding value `b'.  The operation is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_rem(a: float32; b: float32 ):float32;{$ifdef fpc} [public,Alias:'FLOAT32_REM'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_rem(a: float32; b: float32 ):float32;{$ifdef fpc} [public,Alias:'FLOAT32_REM'];compilerproc;{$endif}
   Var
     aSign, bSign, zSign: flag;
     aExp, bExp, expDiff: int16;
@@ -2981,7 +2977,7 @@ The operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_sqrt(a: float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_SQRT'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_sqrt(a: float32 ): float32;{$ifdef fpc} [public,Alias:'FLOAT32_SQRT'];compilerproc;{$endif}
 Var
     aSign : flag;
     aExp, zExp : int16;
@@ -3064,7 +3060,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_eq( a:float32; b:float32): flag;{$ifdef fpc} [public,Alias:'FLOAT32_EQ'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_eq( a:float32; b:float32): flag;{$ifdef fpc} [public,Alias:'FLOAT32_EQ'];compilerproc;{$endif}
 Begin
     if ((( extractFloat32Exp( a ) = $FF ) AND  (extractFloat32Frac( a )<>0))
          OR ( ( extractFloat32Exp( b ) = $FF ) AND  (extractFloat32Frac( b )<>0) )
@@ -3088,7 +3084,7 @@ is performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_le( a: float32; b : float32 ):flag;{$ifdef fpc} [public,Alias:'FLOAT32_LE'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_le( a: float32; b : float32 ):flag;{$ifdef fpc} [public,Alias:'FLOAT32_LE'];compilerproc;{$endif}
 var
     aSign, bSign: flag;
 Begin
@@ -3119,7 +3115,7 @@ the corresponding value `b', and 0 otherwise.  The comparison is performed
 according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float32_lt( a:float32 ; b : float32): flag;{$ifdef fpc} [public,Alias:'FLOAT32_LT'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float32_lt( a:float32 ; b : float32): flag;{$ifdef fpc} [public,Alias:'FLOAT32_LT'];compilerproc;{$endif}
 var
     aSign, bSign: flag;
 Begin
@@ -3243,7 +3239,7 @@ positive integer is returned.  Otherwise, if the conversion overflows, the
 largest integer with the same sign as `a' is returned.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_int32(a: float64): int32;{$ifdef fpc} [public,Alias:'FLOAT64_TO_INT32'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float64_to_int32(a: float64): int32;{$ifdef fpc} [public,Alias:'FLOAT64_TO_INT32'];compilerproc;{$endif}
 var
     aSign: flag;
     aExp, shiftCount: int16;
@@ -3340,7 +3336,7 @@ returned.
 -------------------------------------------------------------------------------
 *}
 Function float64_to_int32_round_to_zero(a: float64 ): int32;
-{$ifdef fpc} [public,Alias:'FLOAT64_TO_INT32_ROUND_TO_ZERO'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc} [public,Alias:'FLOAT64_TO_INT32_ROUND_TO_ZERO'];compilerproc;{$endif}
 Var
     aSign: flag;
     aExp, shiftCount: int16;
@@ -3407,7 +3403,7 @@ performed according to the IEC/IEEE Standard for Binary Floating-Point
 Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Function float64_to_float32(a: float64 ): float32;{$ifdef fpc} [public,Alias:'FLOAT64_TO_FLOAT32'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Function float64_to_float32(a: float64 ): float32;{$ifdef fpc} [public,Alias:'FLOAT64_TO_FLOAT32'];compilerproc;{$endif}
 Var
     aSign: flag;
     aExp: int16;
@@ -3444,7 +3440,7 @@ operation is performed according to the IEC/IEEE Standard for Binary
 Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
-Procedure float64_round_to_int(a: float64; var out: float64 );{$ifdef fpc} [public,Alias:'FLOAT64_ROUND_TO_INT'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+Procedure float64_round_to_int(a: float64; var out: float64 );{$ifdef fpc} [public,Alias:'FLOAT64_ROUND_TO_INT'];compilerproc;{$endif}
 
 Var
     aSign: flag;
@@ -3809,7 +3805,7 @@ Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Procedure float64_add( a: float64; b : float64; Var out : float64);
-{$ifdef fpc}[public,Alias:'FLOAT64_ADD'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_ADD'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -3833,7 +3829,7 @@ for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Procedure float64_sub(a: float64; b : float64; var out: float64);
-{$ifdef fpc}[public,Alias:'FLOAT64_SUB'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_SUB'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -3857,7 +3853,7 @@ for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Procedure float64_mul( a: float64; b:float64; Var out: float64);
-{$ifdef fpc}[public,Alias:'FLOAT64_MUL'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_MUL'];compilerproc;{$endif}
 Var
     aSign, bSign, zSign: flag;
     aExp, bExp, zExp: int16;
@@ -3946,7 +3942,7 @@ IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Procedure float64_div(a: float64; b : float64 ; var out: float64 );
-{$ifdef fpc}[public,Alias:'FLOAT64_DIV'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_DIV'];compilerproc;{$endif}
 Var
     aSign, bSign, zSign: flag;
     aExp, bExp, zExp: int16;
@@ -4062,7 +4058,7 @@ according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Procedure float64_rem(a: float64; b : float64; var out: float64);
-{$ifdef fpc}[public,Alias:'FLOAT64_REM'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_REM'];compilerproc;{$endif}
 Var
     aSign, bSign, zSign: flag;
     aExp, bExp, expDiff: int16;
@@ -4202,7 +4198,7 @@ Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Procedure float64_sqrt( a: float64; var out: float64 );
-{$ifdef fpc}[public,Alias:'FLOAT64_SQRT'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_SQRT'];compilerproc;{$endif}
 Var
     aSign: flag;
     aExp, zExp: int16;
@@ -4299,7 +4295,7 @@ according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_eq(a: float64; b: float64): flag;
-{$ifdef fpc}[public,Alias:'FLOAT64_EQ'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_EQ'];compilerproc;{$endif}
 Begin
     if
          (
@@ -4339,7 +4335,7 @@ Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_le(a: float64;b: float64): flag;
-{$ifdef fpc}[public,Alias:'FLOAT64_LE'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_LE'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -4387,7 +4383,7 @@ according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 -------------------------------------------------------------------------------
 *}
 Function float64_lt(a: float64;b: float64): flag;
-{$ifdef fpc}[public,Alias:'FLOAT64_LT'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'FLOAT64_LT'];compilerproc;{$endif}
 Var
     aSign, bSign: flag;
 Begin
@@ -4571,7 +4567,7 @@ End;
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
 function int64_to_float32( a: int64 ): float32;
-{$ifdef fpc}[public,Alias:'INT64_TO_FLOAT32'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'INT64_TO_FLOAT32'];compilerproc;{$endif}
 var
     zSign : flag;
     absA : uint64;
@@ -4622,7 +4618,7 @@ End;
 | according to the IEC/IEEE Standard for Binary Floating-Point Arithmetic.
 *----------------------------------------------------------------------------*}
 function int64_to_float64( a: int64 ): float64;
-{$ifdef fpc}[public,Alias:'INT64_TO_FLOAT64'];{$ifdef hascompilerproc} compilerproc; {$endif}{$endif}
+{$ifdef fpc}[public,Alias:'INT64_TO_FLOAT64'];compilerproc;{$endif}
 var
  zSign : flag;
  float_result : float64;

rtl/inc/sstrings.inc

@@ -15,7 +15,7 @@
                     subroutines for string handling
 ****************************************************************************}
 
-procedure fpc_Shortstr_SetLength(var s:shortstring;len:SizeInt);[Public,Alias : 'FPC_SHORTSTR_SETLENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_Shortstr_SetLength(var s:shortstring;len:SizeInt);[Public,Alias : 'FPC_SHORTSTR_SETLENGTH']; compilerproc;
 begin
   if Len>255 then
    Len:=255;
@@ -352,9 +352,9 @@ end;
 *****************************************************************************}
 
 {$ifdef STR_USES_VALINT}
-procedure fpc_shortstr_SInt(v : valSInt;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_SINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_shortstr_SInt(v : valSInt;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_SINT']; compilerproc;
 {$else}
-procedure fpc_shortstr_longint(v : longint;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_LONGINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_shortstr_longint(v : longint;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_LONGINT']; compilerproc;
 {$endif}
 begin
   int_str(v,s);
@@ -363,9 +363,9 @@ begin
 end;
 
 {$ifdef STR_USES_VALINT}
-procedure fpc_shortstr_UInt(v : valUInt;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_UINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_shortstr_UInt(v : valUInt;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_UINT']; compilerproc;
 {$else}
-  procedure fpc_shortstr_longword(v : longword;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_LONGWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+  procedure fpc_shortstr_longword(v : longword;len : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_LONGWORD']; compilerproc;
 {$endif}
 begin
   int_str(v,s);
@@ -375,7 +375,7 @@ end;
 
 {$ifndef CPU64}
 
-  procedure fpc_shortstr_qword(v : qword;len : longint;var s : shortstring);[public,alias:'FPC_SHORTSTR_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+  procedure fpc_shortstr_qword(v : qword;len : longint;var s : shortstring);[public,alias:'FPC_SHORTSTR_QWORD']; compilerproc;
     begin
        int_str(v,s);
        if length(s)<len then
@@ -383,7 +383,7 @@ end;
     end;
 
 
-  procedure fpc_shortstr_int64(v : int64;len : longint;var s : shortstring);[public,alias:'FPC_SHORTSTR_INT64'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+  procedure fpc_shortstr_int64(v : int64;len : longint;var s : shortstring);[public,alias:'FPC_SHORTSTR_INT64'];  compilerproc;
     begin
        int_str(v,s);
        if length(s)<len then
@@ -399,7 +399,7 @@ end;
 
 {$I real2str.inc}
 
-procedure fpc_ShortStr_Float(d : ValReal;len,fr,rt : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_FLOAT']; {$ifdef hascompilerproc}compilerproc;{$endif hascompilerproc}
+procedure fpc_ShortStr_Float(d : ValReal;len,fr,rt : SizeInt;var s : shortstring);[public,alias:'FPC_SHORTSTR_FLOAT']; compilerproc;
 begin
   str_real(len,fr,d,treal_type(rt),s);
 end;
@@ -410,9 +410,9 @@ end;
 }
 
 {$ifdef STR_USES_VALINT}
-procedure fpc_chararray_sint(v : valsint;len : SizeInt;var a:array of char);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_chararray_sint(v : valsint;len : SizeInt;var a:array of char);compilerproc;
 {$else}
-procedure fpc_chararray_longint(v : longint;len : SizeInt;var a:array of char);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_chararray_longint(v : longint;len : SizeInt;var a:array of char);compilerproc;
 {$endif}
 var
   ss : shortstring;
@@ -430,9 +430,9 @@ end;
 
 
 {$ifdef STR_USES_VALINT}
-procedure fpc_chararray_uint(v : valuint;len : SizeInt;var a : array of char);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_chararray_uint(v : valuint;len : SizeInt;var a : array of char);compilerproc;
 {$else}
-procedure fpc_chararray_longword(v : longword;len : SizeInt;var a : array of char);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_chararray_longword(v : longword;len : SizeInt;var a : array of char);compilerproc;
 {$endif}
 var
   ss : shortstring;
@@ -451,7 +451,7 @@ end;
 
 {$ifndef CPU64}
 
-procedure fpc_chararray_qword(v : qword;len : SizeInt;var a : array of char);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_chararray_qword(v : qword;len : SizeInt;var a : array of char);compilerproc;
 var
   ss : shortstring;
   maxlen : SizeInt;
@@ -467,7 +467,7 @@ begin
 end;
 
 
-procedure fpc_chararray_int64(v : int64;len : SizeInt;var a : array of char);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_chararray_int64(v : int64;len : SizeInt;var a : array of char);compilerproc;
 var
   ss : shortstring;
   maxlen : SizeInt;
@@ -485,7 +485,7 @@ end;
 {$endif CPU64}
 
 
-procedure fpc_chararray_Float(d : ValReal;len,fr,rt : SizeInt;var a : array of char);{$ifdef hascompilerproc}compilerproc;{$endif hascompilerproc}
+procedure fpc_chararray_Float(d : ValReal;len,fr,rt : SizeInt;var a : array of char);compilerproc;
 var
   ss : shortstring;
   maxlen : SizeInt;
@@ -554,7 +554,7 @@ begin
 end;
 
 
-Function fpc_Val_SInt_ShortStr(DestSize: SizeInt; Const S: ShortString; var Code: ValSInt): ValSInt; [public, alias:'FPC_VAL_SINT_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_SInt_ShortStr(DestSize: SizeInt; Const S: ShortString; var Code: ValSInt): ValSInt; [public, alias:'FPC_VAL_SINT_SHORTSTR']; compilerproc;
 var
   u, temp, prev, maxPrevValue, maxNewValue: ValUInt;
   base : byte;
@@ -610,7 +610,7 @@ end;
 Function int_Val_SInt_ShortStr(DestSize: SizeInt; Const S: ShortString; var Code: ValSInt): ValSInt; [external name 'FPC_VAL_SINT_SHORTSTR'];
 
 
-Function fpc_Val_UInt_Shortstr(Const S: ShortString; var Code: ValSInt): ValUInt; [public, alias:'FPC_VAL_UINT_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_UInt_Shortstr(Const S: ShortString; var Code: ValSInt): ValUInt; [public, alias:'FPC_VAL_UINT_SHORTSTR']; compilerproc;
 var
   u, prev : ValUInt;
   base : byte;
@@ -645,7 +645,7 @@ end;
 
 {$ifndef CPU64}
 
-  Function fpc_val_int64_shortstr(Const S: ShortString; var Code: ValSInt): Int64; [public, alias:'FPC_VAL_INT64_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+  Function fpc_val_int64_shortstr(Const S: ShortString; var Code: ValSInt): Int64; [public, alias:'FPC_VAL_INT64_SHORTSTR']; compilerproc;
    type
      QWordRec = packed record
        l1,l2: longint;
@@ -710,7 +710,7 @@ end;
   end;
 
 
-  Function fpc_val_qword_shortstr(Const S: ShortString; var Code: ValSInt): QWord; [public, alias:'FPC_VAL_QWORD_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+  Function fpc_val_qword_shortstr(Const S: ShortString; var Code: ValSInt): QWord; [public, alias:'FPC_VAL_QWORD_SHORTSTR']; compilerproc;
     type qwordrec = packed record
       l1,l2: longint;
     end;
@@ -753,7 +753,7 @@ end;
 {$endif CPU64}
 
 
-Function fpc_Val_Real_ShortStr(const s : shortstring; var code : ValSInt): ValReal; [public, alias:'FPC_VAL_REAL_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_Real_ShortStr(const s : shortstring; var code : ValSInt): ValReal; [public, alias:'FPC_VAL_REAL_SHORTSTR']; compilerproc;
 var
   hd,
   esign,sign : valreal;

rtl/inc/system.inc

@@ -511,23 +511,23 @@ end;
                              Miscellaneous
 *****************************************************************************}
 
-procedure fpc_rangeerror;[public,alias:'FPC_RANGEERROR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_rangeerror;[public,alias:'FPC_RANGEERROR']; compilerproc;
 begin
   HandleErrorFrame(201,get_frame);
 end;
 
-procedure fpc_divbyzero;[public,alias:'FPC_DIVBYZERO']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_divbyzero;[public,alias:'FPC_DIVBYZERO']; compilerproc;
 begin
   HandleErrorFrame(200,get_frame);
 end;
 
-procedure fpc_overflow;[public,alias:'FPC_OVERFLOW']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_overflow;[public,alias:'FPC_OVERFLOW']; compilerproc;
 begin
   HandleErrorFrame(215,get_frame);
 end;
 
 
-procedure fpc_iocheck;{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias:'FPC_IOCHECK']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_iocheck;{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[public,alias:'FPC_IOCHECK']; compilerproc;
 var
   l : longint;
 begin
@@ -604,7 +604,7 @@ type
 var
   InitFinalTable : TInitFinalTable;external name 'INITFINAL';
 
-procedure fpc_InitializeUnits;[public,alias:'FPC_INITIALIZEUNITS']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_InitializeUnits;[public,alias:'FPC_INITIALIZEUNITS']; compilerproc;
 var
   i : longint;
 begin
@@ -933,7 +933,7 @@ end;
                           Abstract/Assert support.
 *****************************************************************************}
 
-procedure fpc_AbstractErrorIntern;{$ifdef hascompilerproc}compilerproc;{$endif}[public,alias : 'FPC_ABSTRACTERROR'];
+procedure fpc_AbstractErrorIntern;compilerproc;[public,alias : 'FPC_ABSTRACTERROR'];
 begin
   If pointer(AbstractErrorProc)<>nil then
     AbstractErrorProc();
@@ -941,7 +941,7 @@ begin
 end;
 
 
-Procedure fpc_assert(Const Msg,FName:Shortstring;LineNo:Longint;ErrorAddr:Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [Public,Alias : 'FPC_ASSERT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_assert(Const Msg,FName:Shortstring;LineNo:Longint;ErrorAddr:Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif} [Public,Alias : 'FPC_ASSERT']; compilerproc;
 begin
   if pointer(AssertErrorProc)<>nil then
     AssertErrorProc(Msg,FName,LineNo,ErrorAddr)

rtl/inc/text.inc

@@ -435,13 +435,13 @@ Begin
 End;
 
 
-Function fpc_get_input:PText;{$ifdef hascompilerproc}compilerproc;{$endif}
+Function fpc_get_input:PText;compilerproc;
 begin
   fpc_get_input:=@Input;
 end;
 
 
-Function fpc_get_output:PText;{$ifdef hascompilerproc}compilerproc;{$endif}
+Function fpc_get_output:PText;compilerproc;
 begin
   fpc_get_output:=@Output;
 end;
@@ -492,14 +492,14 @@ begin
 end;
 
 
-Procedure fpc_Write_End(var f:Text);[Public,Alias:'FPC_WRITE_END']; iocheck; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_End(var f:Text);[Public,Alias:'FPC_WRITE_END']; iocheck; compilerproc;
 begin
   if TextRec(f).FlushFunc<>nil then
    FileFunc(TextRec(f).FlushFunc)(TextRec(f));
 end;
 
 
-Procedure fpc_Writeln_End(var f:Text);[Public,Alias:'FPC_WRITELN_END']; iocheck; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Writeln_End(var f:Text);[Public,Alias:'FPC_WRITELN_END']; iocheck; compilerproc;
 begin
   If InOutRes <> 0 then exit;
   case TextRec(f).mode of
@@ -517,7 +517,7 @@ begin
 end;
 
 
-Procedure fpc_Write_Text_ShortStr(Len : Longint;var f : Text;const s : String); iocheck; [Public,Alias:'FPC_WRITE_TEXT_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_ShortStr(Len : Longint;var f : Text;const s : String); iocheck; [Public,Alias:'FPC_WRITE_TEXT_SHORTSTR']; compilerproc;
 Begin
   If (InOutRes<>0) then
    exit;
@@ -537,7 +537,7 @@ End;
 procedure Write_Str(Len : Longint;var f : Text;const s : String); iocheck; [external name 'FPC_WRITE_TEXT_SHORTSTR'];
 
 
-Procedure fpc_Write_Text_Pchar_as_Array(Len : Longint;var f : Text;const s : array of char); iocheck; [Public,Alias:'FPC_WRITE_TEXT_PCHAR_AS_ARRAY']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_Pchar_as_Array(Len : Longint;var f : Text;const s : array of char); iocheck; [Public,Alias:'FPC_WRITE_TEXT_PCHAR_AS_ARRAY']; compilerproc;
 var
   ArrayLen : longint;
   p : pchar;
@@ -564,7 +564,7 @@ Begin
 End;
 
 
-Procedure fpc_Write_Text_PChar_As_Pointer(Len : Longint;var f : Text;p : PChar); iocheck; [Public,Alias:'FPC_WRITE_TEXT_PCHAR_AS_POINTER']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_PChar_As_Pointer(Len : Longint;var f : Text;p : PChar); iocheck; [Public,Alias:'FPC_WRITE_TEXT_PCHAR_AS_POINTER']; compilerproc;
 var
   PCharLen : longint;
 Begin
@@ -584,7 +584,7 @@ Begin
 End;
 
 
-Procedure fpc_Write_Text_AnsiStr (Len : Longint; Var f : Text; S : AnsiString); iocheck; [Public,alias:'FPC_WRITE_TEXT_ANSISTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_AnsiStr (Len : Longint; Var f : Text; S : AnsiString); iocheck; [Public,alias:'FPC_WRITE_TEXT_ANSISTR']; compilerproc;
 {
  Writes a AnsiString to the Text file T
 }
@@ -608,7 +608,7 @@ begin
 end;
 
 
-Procedure fpc_Write_Text_WideStr (Len : Longint; Var f : Text; S : WideString); iocheck; [Public,alias:'FPC_WRITE_TEXT_WIDESTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_WideStr (Len : Longint; Var f : Text; S : WideString); iocheck; [Public,alias:'FPC_WRITE_TEXT_WIDESTR']; compilerproc;
 {
  Writes a WideString to the Text file T
 }
@@ -630,7 +630,7 @@ begin
   end;
 end;
 
-Procedure fpc_Write_Text_SInt(Len : Longint;var t : Text;l : ValSInt); iocheck; [Public,Alias:'FPC_WRITE_TEXT_SINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_SInt(Len : Longint;var t : Text;l : ValSInt); iocheck; [Public,Alias:'FPC_WRITE_TEXT_SINT']; compilerproc;
 var
   s : String;
 Begin
@@ -641,7 +641,7 @@ Begin
 End;
 
 
-Procedure fpc_Write_Text_UInt(Len : Longint;var t : Text;l : ValUInt); iocheck; [Public,Alias:'FPC_WRITE_TEXT_UINT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_UInt(Len : Longint;var t : Text;l : ValUInt); iocheck; [Public,Alias:'FPC_WRITE_TEXT_UINT']; compilerproc;
 var
   s : String;
 Begin
@@ -654,7 +654,7 @@ End;
 
 {$ifndef CPU64}
 
-procedure fpc_write_text_qword(len : longint;var t : text;q : qword); iocheck; [public,alias:'FPC_WRITE_TEXT_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_write_text_qword(len : longint;var t : text;q : qword); iocheck; [public,alias:'FPC_WRITE_TEXT_QWORD']; compilerproc;
 var
   s : string;
 begin
@@ -664,7 +664,7 @@ begin
   write_str(len,t,s);
 end;
 
-procedure fpc_write_text_int64(len : longint;var t : text;i : int64); iocheck; [public,alias:'FPC_WRITE_TEXT_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_write_text_int64(len : longint;var t : text;i : int64); iocheck; [public,alias:'FPC_WRITE_TEXT_INT64']; compilerproc;
 var
   s : string;
 begin
@@ -676,7 +676,7 @@ end;
 
 {$endif CPU64}
 
-Procedure fpc_Write_Text_Float(rt,fixkomma,Len : Longint;var t : Text;r : ValReal); iocheck; [Public,Alias:'FPC_WRITE_TEXT_FLOAT']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_Float(rt,fixkomma,Len : Longint;var t : Text;r : ValReal); iocheck; [Public,Alias:'FPC_WRITE_TEXT_FLOAT']; compilerproc;
 var
   s : String;
 Begin
@@ -687,7 +687,7 @@ Begin
 End;
 
 
-Procedure fpc_Write_Text_Boolean(Len : Longint;var t : Text;b : Boolean); iocheck; [Public,Alias:'FPC_WRITE_TEXT_BOOLEAN']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_Boolean(Len : Longint;var t : Text;b : Boolean); iocheck; [Public,Alias:'FPC_WRITE_TEXT_BOOLEAN']; compilerproc;
 Begin
   If (InOutRes<>0) then
    exit;
@@ -699,7 +699,7 @@ Begin
 End;
 
 
-Procedure fpc_Write_Text_Char(Len : Longint;var t : Text;c : Char); iocheck; [Public,Alias:'FPC_WRITE_TEXT_CHAR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_Char(Len : Longint;var t : Text;c : Char); iocheck; [Public,Alias:'FPC_WRITE_TEXT_CHAR']; compilerproc;
 Begin
   If (InOutRes<>0) then
     exit;
@@ -720,7 +720,7 @@ Begin
 End;
 
 
-Procedure fpc_Write_Text_WideChar(Len : Longint;var t : Text;c : WideChar); iocheck; [Public,Alias:'FPC_WRITE_TEXT_WIDECHAR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Write_Text_WideChar(Len : Longint;var t : Text;c : WideChar); iocheck; [Public,Alias:'FPC_WRITE_TEXT_WIDECHAR']; compilerproc;
 var
   ch : char;
 Begin
@@ -809,14 +809,14 @@ begin
 end;
 
 
-Procedure fpc_Read_End(var f:Text);[Public,Alias:'FPC_READ_END']; iocheck; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Read_End(var f:Text);[Public,Alias:'FPC_READ_END']; iocheck; compilerproc;
 begin
   if TextRec(f).FlushFunc<>nil then
    FileFunc(TextRec(f).FlushFunc)(TextRec(f));
 end;
 
 
-Procedure fpc_ReadLn_End(var f : Text);[Public,Alias:'FPC_READLN_END']; iocheck; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_ReadLn_End(var f : Text);[Public,Alias:'FPC_READLN_END']; iocheck; compilerproc;
 var prev: char;
 Begin
 { Check error and if file is open and load buf if empty }
@@ -934,19 +934,19 @@ Begin
 End;
 
 
-Procedure fpc_Read_Text_ShortStr(var f : Text;out s : String); iocheck; [Public,Alias:'FPC_READ_TEXT_SHORTSTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Read_Text_ShortStr(var f : Text;out s : String); iocheck; [Public,Alias:'FPC_READ_TEXT_SHORTSTR']; compilerproc;
 Begin
   s[0]:=chr(ReadPCharLen(f,pchar(@s[1]),high(s)));
 End;
 
 
-Procedure fpc_Read_Text_PChar_As_Pointer(var f : Text;out s : PChar); iocheck; [Public,Alias:'FPC_READ_TEXT_PCHAR_AS_POINTER']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Read_Text_PChar_As_Pointer(var f : Text;out s : PChar); iocheck; [Public,Alias:'FPC_READ_TEXT_PCHAR_AS_POINTER']; compilerproc;
 Begin
   pchar(s+ReadPCharLen(f,s,$7fffffff))^:=#0;
 End;
 
 
-Procedure fpc_Read_Text_PChar_As_Array(var f : Text;out s : array of char); iocheck; [Public,Alias:'FPC_READ_TEXT_PCHAR_AS_ARRAY']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Read_Text_PChar_As_Array(var f : Text;out s : array of char); iocheck; [Public,Alias:'FPC_READ_TEXT_PCHAR_AS_ARRAY']; compilerproc;
 var
   len: longint;
 Begin
@@ -956,7 +956,7 @@ Begin
 End;
 
 
-Procedure fpc_Read_Text_AnsiStr(var f : Text;out s : AnsiString); iocheck; [Public,Alias:'FPC_READ_TEXT_ANSISTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_Read_Text_AnsiStr(var f : Text;out s : AnsiString); iocheck; [Public,Alias:'FPC_READ_TEXT_ANSISTR']; compilerproc;
 var
   slen,len : longint;
 Begin
@@ -971,17 +971,9 @@ Begin
   SetLength(S,Slen);
 End;
 
-{$ifdef hascompilerproc}
 procedure fpc_Read_Text_Char(var f : Text; out c: char); iocheck; [Public,Alias:'FPC_READ_TEXT_CHAR'];compilerproc;
-{$else hascompilerproc}
-Function fpc_Read_Text_Char(var f : Text):char;[Public,Alias:'FPC_READ_TEXT_CHAR'];
-{$endif hascompilerproc}
 Begin
-{$ifdef hascompilerproc}
   c:=#0;
-{$else hascompilerproc}
-  fpc_Read_Text_Char:=#0;
-{$endif hascompilerproc}
 { Check error and if file is open }
   If (InOutRes<>0) then
    exit;
@@ -1000,38 +992,22 @@ Begin
    begin
      FileFunc(TextRec(f).InOutFunc)(TextRec(f));
      If TextRec(f).BufPos>=TextRec(f).BufEnd Then
-{$ifdef hascompilerproc}
        begin
          c := #26;
          exit;
        end;
-{$else hascompilerproc}
-       exit(#26);
-{$endif hascompilerproc}
    end;
-{$ifdef hascompilerproc}
   c:=TextRec(f).Bufptr^[TextRec(f).BufPos];
-{$else hascompilerproc}
-  fpc_Read_Text_Char:=TextRec(f).Bufptr^[TextRec(f).BufPos];
-{$endif hascompilerproc}
   inc(TextRec(f).BufPos);
 end;
 
 
-{$ifdef hascompilerproc}
 Procedure fpc_Read_Text_SInt(var f : Text; out l : ValSInt); iocheck; [Public,Alias:'FPC_READ_TEXT_SINT']; compilerproc;
-{$else hascompilerproc}
-Function fpc_Read_Text_SInt(var f : Text):ValSInt;[Public,Alias:'FPC_READ_TEXT_SINT'];
-{$endif hascompilerproc}
 var
   hs   : String;
   code : longint;
 Begin
-{$ifdef hascompilerproc}
   l:=0;
-{$else hascompilerproc}
-  fpc_Read_Text_SInt:=0;
-{$endif hascompilerproc}
 { Leave if error or not open file, else check for empty buf }
   If (InOutRes<>0) then
    exit;
@@ -1058,7 +1034,6 @@ Begin
       exit;
      ReadNumeric(f,hs);
    end;
-{$ifdef hascompilerproc}
    if (hs = '') then
     L := 0
    else
@@ -1067,33 +1042,15 @@ Begin
      if Code <> 0 then
       InOutRes:=106;
     end;
-{$else hascompilerproc}
-   if (hs = '') then
-    fpc_Read_Text_SInt := 0
-   else
-    begin
-     Val(hs,fpc_Read_Text_SInt,code);
-     if Code <> 0 then
-      InOutRes:=106;
-    end;
-{$endif hascompilerproc}
 End;
 
 
-{$ifdef hascompilerproc}
 Procedure fpc_Read_Text_UInt(var f : Text; out u : ValUInt);  iocheck; [Public,Alias:'FPC_READ_TEXT_UINT']; compilerproc;
-{$else hascompilerproc}
-Function fpc_Read_Text_UInt(var f : Text):ValUInt;[Public,Alias:'FPC_READ_TEXT_UINT'];
-{$endif hascompilerproc}
 var
   hs   : String;
   code : longint;
 Begin
-{$ifdef hascompilerproc}
   u:=0;
-{$else hascompilerproc}
-  fpc_Read_Text_UInt:=0;
-{$endif hascompilerproc}
 { Leave if error or not open file, else check for empty buf }
   If (InOutRes<>0) then
    exit;
@@ -1118,30 +1075,18 @@ Begin
       exit;
      ReadNumeric(f,hs);
    end;
-{$ifdef hascompilerproc}
   val(hs,u,code);
-{$else hascompilerproc}
-  val(hs,fpc_Read_Text_UInt,code);
-{$endif hascompilerproc}
   If code<>0 Then
    InOutRes:=106;
 End;
 
 
-{$ifdef hascompilerproc}
 procedure fpc_Read_Text_Float(var f : Text; out v : ValReal); iocheck; [Public,Alias:'FPC_READ_TEXT_FLOAT']; compilerproc;
-{$else hascompilerproc}
-Function fpc_Read_Text_Float(var f : Text):ValReal;[Public,Alias:'FPC_READ_TEXT_FLOAT'];
-{$endif hascompilerproc}
 var
   hs : string;
   code : Word;
 begin
-{$ifdef hascompilerproc}
   v:=0.0;
-{$else hascompilerproc}
-  fpc_Read_Text_Float:=0.0;
-{$endif hascompilerproc}
 { Leave if error or not open file, else check for empty buf }
   If (InOutRes<>0) then
    exit;
@@ -1166,11 +1111,7 @@ begin
       exit;
      ReadNumeric(f,hs);
    end;
-{$ifdef hascompilerproc}
   val(hs,v,code);
-{$else hascompilerproc}
-  val(hs,fpc_Read_Text_Float,code);
-{$endif hascompilerproc}
   If code<>0 Then
    InOutRes:=106;
 end;
@@ -1178,20 +1119,12 @@ end;
 
 {$ifndef cpu64}
 
-{$ifdef hascompilerproc}
 procedure fpc_Read_Text_QWord(var f : text; out q : qword); iocheck; [public,alias:'FPC_READ_TEXT_QWORD']; compilerproc;
-{$else hascompilerproc}
-function fpc_Read_Text_QWord(var f : text) : qword;[public,alias:'FPC_READ_TEXT_QWORD'];
-{$endif hascompilerproc}
 var
   hs   : String;
   code : longint;
 Begin
-{$ifdef hascompilerproc}
   q:=0;
-{$else hascompilerproc}
-  fpc_Read_Text_QWord:=0;
-{$endif hascompilerproc}
   { Leave if error or not open file, else check for empty buf }
   If (InOutRes<>0) then
    exit;
@@ -1216,29 +1149,17 @@ Begin
       exit;
      ReadNumeric(f,hs);
    end;
-{$ifdef hascompilerproc}
   val(hs,q,code);
-{$else hascompilerproc}
-  val(hs,fpc_Read_Text_QWord,code);
-{$endif hascompilerproc}
   If code<>0 Then
    InOutRes:=106;
 End;
 
-{$ifdef hascompilerproc}
 procedure fpc_Read_Text_Int64(var f : text; out i : int64); iocheck; [public,alias:'FPC_READ_TEXT_INT64']; compilerproc;
-{$else hascompilerproc}
-function fpc_Read_Text_Int64(var f : text) : int64;[public,alias:'FPC_READ_TEXT_INT64']; {$ifdef hascompilerproc} compilerproc; {$endif}
-{$endif hascompilerproc}
 var
   hs   : String;
   code : Longint;
 Begin
-{$ifdef hascompilerproc}
   i:=0;
-{$else hascompilerproc}
-  fpc_Read_Text_Int64:=0;
-{$endif hascompilerproc}
 { Leave if error or not open file, else check for empty buf }
   If (InOutRes<>0) then
    exit;
@@ -1263,11 +1184,7 @@ Begin
       exit;
      ReadNumeric(f,hs);
    end;
-{$ifdef hascompilerproc}
   Val(hs,i,code);
-{$else hascompilerproc}
-  Val(hs,fpc_Read_Text_Int64,code);
-{$endif hascompilerproc}
   If code<>0 Then
    InOutRes:=106;
 End;

rtl/inc/typefile.inc

@@ -45,7 +45,7 @@ begin
 end;
 
 
-Procedure fpc_reset_typed(var f : TypedFile;Size : Longint);[Public,IOCheck, Alias:'FPC_RESET_TYPED']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_reset_typed(var f : TypedFile;Size : Longint);[Public,IOCheck, Alias:'FPC_RESET_TYPED']; compilerproc;
 Begin
   If InOutRes <> 0 then
    exit;
@@ -53,7 +53,7 @@ Begin
 End;
 
 
-Procedure fpc_rewrite_typed(var f : TypedFile;Size : Longint);[Public,IOCheck, Alias:'FPC_REWRITE_TYPED']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_rewrite_typed(var f : TypedFile;Size : Longint);[Public,IOCheck, Alias:'FPC_REWRITE_TYPED']; compilerproc;
 Begin
   If InOutRes <> 0 then
    exit;
@@ -61,7 +61,7 @@ Begin
 End;
 
 
-Procedure fpc_typed_write(TypeSize : Longint;var f : TypedFile;const Buf);[IOCheck, Public, Alias :'FPC_TYPED_WRITE']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_typed_write(TypeSize : Longint;var f : TypedFile;const Buf);[IOCheck, Public, Alias :'FPC_TYPED_WRITE']; compilerproc;
 Begin
   If InOutRes <> 0 then
    exit;
@@ -73,7 +73,7 @@ Begin
   end;
 End;
 
-Procedure fpc_typed_read(TypeSize : Longint;var f : TypedFile;var Buf);[IOCheck, Public, Alias :'FPC_TYPED_READ']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_typed_read(TypeSize : Longint;var f : TypedFile;var Buf);[IOCheck, Public, Alias :'FPC_TYPED_READ']; compilerproc;
 var
   Result : Longint;
 Begin

rtl/inc/wstrings.inc

@@ -168,7 +168,7 @@ begin
 end;
 
 
-Procedure fpc_WideStr_Decr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_WIDESTR_DECR_REF']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_Decr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_WIDESTR_DECR_REF']; compilerproc;
 {
   Decreases the ReferenceCount of a non constant widestring;
   If the reference count is zero, deallocate the string;
@@ -193,16 +193,10 @@ Begin
 {$endif}
 end;
 
-{$ifdef hascompilerproc}
 { alias for internal use }
 Procedure fpc_WideStr_Decr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[external name 'FPC_WIDESTR_DECR_REF'];
-{$endif compilerproc}
 
-{$ifdef hascompilerproc}
-Procedure fpc_WideStr_Incr_Ref (S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_WIDESTR_INCR_REF']; {$ifdef hascompilerproc} compilerproc; {$endif}
-{$else}
-Procedure fpc_WideStr_Incr_Ref (Var S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_WIDESTR_INCR_REF'];
-{$endif compilerproc}
+Procedure fpc_WideStr_Incr_Ref (S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[Public,Alias:'FPC_WIDESTR_INCR_REF']; compilerproc;
 Begin
   If S=Nil then
     exit;
@@ -211,12 +205,10 @@ Begin
   inclocked(PWideRec(S-WideFirstOff)^.Ref);
 end;
 
-{$ifdef hascompilerproc}
 { alias for internal use }
 Procedure fpc_WideStr_Incr_Ref (S : Pointer);{$ifndef NOSAVEREGISTERS}saveregisters;{$endif}[external name 'FPC_WIDESTR_INCR_REF'];
-{$endif compilerproc}
 
-function fpc_WideStr_To_ShortStr (high_of_res: SizeInt;const S2 : WideString): shortstring;[Public, alias: 'FPC_WIDESTR_TO_SHORTSTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
+function fpc_WideStr_To_ShortStr (high_of_res: SizeInt;const S2 : WideString): shortstring;[Public, alias: 'FPC_WIDESTR_TO_SHORTSTR'];  compilerproc;
 {
   Converts a WideString to a ShortString;
 }
@@ -238,7 +230,7 @@ begin
 end;
 
 
-Function fpc_ShortStr_To_WideStr (Const S2 : ShortString): WideString;{$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_ShortStr_To_WideStr (Const S2 : ShortString): WideString;compilerproc;
 {
   Converts a ShortString to a WideString;
 }
@@ -256,16 +248,7 @@ begin
 end;
 
 
-{ old style helper }
-{$ifndef hascompilerproc}
-
-Procedure fpc_ShortStr_To_WideStr (Var S1 : Pointer; Const S2 : ShortString);[Public, alias: 'FPC_SHORTSTR_TO_WIDESTR'];
-begin
-  s1 := pointer(fpc_ShortStr_To_WideStr(s2));
-end;
-{$endif hascompilerproc}
-
-Function fpc_WideStr_To_AnsiStr (const S2 : WideString): AnsiString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_WideStr_To_AnsiStr (const S2 : WideString): AnsiString; compilerproc;
 {
   Converts a WideString to an AnsiString
 }
@@ -284,16 +267,8 @@ begin
    end;
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_WideStr_To_AnsiStr (Var S1 : Pointer;const S2 : WideString);[Public, alias: 'FPC_WIDESTR_TO_ANSISTR'];
-begin
-  s1 := pointer(fpc_WideStr_To_AnsiStr(s2));
-end;
-{$endif hascompilerproc}
 
-
-Function fpc_AnsiStr_To_WideStr (Const S2 : AnsiString): WideString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_AnsiStr_To_WideStr (Const S2 : AnsiString): WideString; compilerproc;
 {
   Converts an AnsiString to a WideString;
 }
@@ -370,17 +345,9 @@ begin
 end;
 
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_AnsiStr_To_WideStr (Var S1 : Pointer; Const S2 : AnsiString);[Public, alias: 'FPC_ANSISTR_TO_WIDESTR'];
-begin
-  s1 := pointer(fpc_AnsiStr_To_WideStr(s2));
-end;
-{$endif hascompilerproc}
-
 
 { checked against the ansistring routine, 2001-05-27 (FK) }
-Procedure fpc_WideStr_Assign (Var S1 : Pointer;S2 : Pointer);[Public,Alias:'FPC_WIDESTR_ASSIGN']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_Assign (Var S1 : Pointer;S2 : Pointer);[Public,Alias:'FPC_WIDESTR_ASSIGN']; compilerproc;
 {
   Assigns S2 to S1 (S1:=S2), taking in account reference counts.
 }
@@ -394,19 +361,13 @@ begin
   S1:=S2;
 end;
 
-{$ifdef hascompilerproc}
 { alias for internal use }
 Procedure fpc_WideStr_Assign (Var S1 : Pointer;S2 : Pointer);[external name 'FPC_WIDESTR_ASSIGN'];
-{$endif hascompilerproc}
 
 { checked against the ansistring routine, 2001-05-27 (FK) }
-{$ifdef hascompilerproc}
 function fpc_WideStr_Concat (const S1,S2 : WideString): WideString; compilerproc;
 var
   S3: WideString absolute result;
-{$else hascompilerproc}
-Procedure fpc_WideStr_Concat (S1,S2 : WideString;var S3 : WideString);[Public, alias: 'FPC_WIDESTR_CONCAT'];
-{$endif hascompilerproc}
 {
   Concatenates 2 WideStrings : S1+S2.
   Result Goes to S3;
@@ -432,7 +393,7 @@ begin
 end;
 
 
-Function fpc_Char_To_WideStr(const c : WideChar): WideString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Char_To_WideStr(const c : WideChar): WideString; compilerproc;
 {
   Converts a Char to a WideString;
 }
@@ -446,16 +407,8 @@ begin
   PWideChar(Pointer(fpc_Char_To_WideStr)+sizeof(WideChar))^:=#0;
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_Char_To_WideStr(var S1 : Pointer; c : WideChar);[Public, alias: 'FPC_CHAR_TO_WIDESTR'];
-begin
-  s1 := pointer(fpc_Char_To_WideStr(c));
-end;
-{$endif hascompilerproc}
 
-
-Function fpc_PChar_To_WideStr(const p : pchar): WideString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_PChar_To_WideStr(const p : pchar): WideString; compilerproc;
 Var
   L : SizeInt;
 begin
@@ -467,16 +420,7 @@ begin
   widestringmanager.Ansi2WideMoveProc(P,fpc_PChar_To_WideStr,l);
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-
-Procedure fpc_PChar_To_WideStr(var a : WideString;p : pchar);[Public,Alias : 'FPC_PCHAR_TO_WIDESTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-begin
-  pointer(a) := pointer(fpc_PChar_To_WideStr(p));
-end;
-{$endif hascompilerproc}
-
-Function fpc_CharArray_To_WideStr(const arr: array of char): WideString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_CharArray_To_WideStr(const arr: array of char): WideString; compilerproc;
 var
   i  : SizeInt;
 begin
@@ -490,42 +434,14 @@ begin
   widestringmanager.Ansi2WideMoveProc (pchar(@arr),fpc_CharArray_To_WideStr,i);
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_CharArray_To_WideStr(var a : WideString; p: pointer; len: SizeInt); [Public,Alias : 'FPC_CHARARRAY_TO_WIDESTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-var
-  src: pchar;
-  i: SizeInt;
-begin
-  src := pchar(p);
-  if src[0]=#0 Then
-    begin
-      pointer(a) := nil;
-      exit;
-    end;
-  i:=IndexChar(src^,len,#0);
-  if i = -1 then
-    i := len;
-  pointer(a) := NewWideString(i);
-  widestringmanager.Ansi2WideMoveProc (src,a,i);
-end;
-{$endif not hascompilerproc}
-
-{$ifdef hascompilerproc}
 function fpc_WideCharArray_To_ShortStr(const arr: array of widechar): shortstring;[public,alias:'FPC_WIDECHARARRAY_TO_SHORTSTR']; compilerproc;
 var
   l: longint;
-{$else hascompilerproc}
-function fpc_WideCharArray_To_ShortStr(arr:pwidechar; l : longint):shortstring;[public,alias:'FPC_WIDECHARARRAY_TO_SHORTSTR'];
-var
-{$endif hascompilerproc}
  index: longint;
  len: byte;
  temp: ansistring;
 begin
-{$ifdef hascompilerproc}
   l := high(arr)+1;
-{$endif hascompilerproc}
   if l>=256 then
     l:=255
   else if l<0 then
@@ -535,16 +451,12 @@ begin
     len := l
   else
     len := index;
-{$ifdef hascompilerproc}
   widestringmanager.Wide2AnsiMoveProc (pwidechar(@arr),temp,len);
-{$else}
-  widestringmanager.Wide2AnsiMoveProc (arr, temp,len);
-{$endif}
   fpc_WideCharArray_To_ShortStr := temp;
   //fpc_WideCharArray_To_ShortStr[0]:=chr(len);
 end;
 
-Function fpc_WideCharArray_To_AnsiStr(const arr: array of widechar): AnsiString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_WideCharArray_To_AnsiStr(const arr: array of widechar): AnsiString; compilerproc;
 var
   i  : SizeInt;
 begin
@@ -558,28 +470,7 @@ begin
   widestringmanager.Wide2AnsiMoveProc (pwidechar(@arr),fpc_WideCharArray_To_AnsiStr,i);
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_WideCharArray_To_AnsiStr(var a : AnsiString; p: pointer; len: SizeInt); [Public,Alias : 'FPC_WIDECHARARRAY_TO_ANSISTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-var
-  src: pwidechar;
-  i: SizeInt;
-begin
-  src := pwidechar(p);
-  if src[0]=#0 Then
-    begin
-      pointer(a) := nil;
-      exit;
-    end;
-  i:=IndexWord(src^,len,0);
-  if i = -1 then
-    i := len;
-  pointer(a) := NewAnsiString(i);
-  widestringmanager.Wide2AnsiMoveProc (src,a,i);
-end;
-{$endif not hascompilerproc}
-
-Function fpc_WideCharArray_To_WideStr(const arr: array of widechar): WideString; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_WideCharArray_To_WideStr(const arr: array of widechar): WideString; compilerproc;
 var
   i  : SizeInt;
 begin
@@ -595,30 +486,6 @@ begin
   PWideChar(Pointer(@fpc_WideCharArray_To_WideStr[1])+i*sizeof(WideChar))^:=#0;
 end;
 
-{ old style helper }
-{$ifndef hascompilerproc}
-Procedure fpc_WideCharArray_To_WideStr(var a : WideString; p: pointer; len: SizeInt); [Public,Alias : 'FPC_WIDECHARARRAY_TO_WIDESTR'];  {$ifdef hascompilerproc} compilerproc; {$endif}
-var
-  src: pwidechar;
-  i: SizeInt;
-begin
-  src := pwidechar(p);
-  if src[0]=#0 Then
-    begin
-      pointer(a) := nil;
-      exit;
-    end;
-  i:=IndexWord(src^,len,#0);
-  if i = -1 then
-    i := len;
-  pointer(a) := NewWideString(i);
-  Move(p^, PWideChar(Pointer(@a[1]))^,i*sizeof(WideChar));
-  { Terminating Zero }
-  PWideChar(Pointer(@a[1])+i*sizeof(WideChar))^:=#0;
-end;
-{$endif not hascompilerproc}
-
-{$ifdef hascompilerproc}
 { inside the compiler, the resulttype is modified to that of the actual }
 { chararray we're converting to (JM)                                    }
 function fpc_widestr_to_chararray(arraysize: SizeInt; const src: WideString): fpc_big_chararray;[public,alias: 'FPC_WIDESTR_TO_CHARARRAY']; compilerproc;
@@ -636,9 +503,7 @@ begin
   move(temp[1],fpc_widestr_to_chararray[0],len);
   fillchar(fpc_widestr_to_chararray[len],arraysize-len,0);
 end;
-{$endif hascompilerproc}
 
-{$ifdef hascompilerproc}
 { inside the compiler, the resulttype is modified to that of the actual }
 { widechararray we're converting to (JM)                                }
 function fpc_widestr_to_widechararray(arraysize: SizeInt; const src: WideString): fpc_big_widechararray;[public,alias: 'FPC_WIDESTR_TO_WIDECHARARRAY']; compilerproc;
@@ -653,9 +518,7 @@ begin
     move(src[1],fpc_widestr_to_widechararray[0],len*SizeOf(WideChar));
   fillchar(fpc_widestr_to_widechararray[len],(arraysize-len)*SizeOf(WideChar),0);
 end;
-{$endif hascompilerproc}
 
-{$ifdef hascompilerproc}
 { inside the compiler, the resulttype is modified to that of the actual }
 { chararray we're converting to (JM)                                    }
 function fpc_ansistr_to_widechararray(arraysize: SizeInt; const src: AnsiString): fpc_big_widechararray;[public,alias: 'FPC_ANSISTR_TO_WIDECHARARRAY']; compilerproc;
@@ -674,9 +537,7 @@ begin
   move(temp[1],fpc_ansistr_to_widechararray[0],len*sizeof(widechar));
   fillchar(fpc_ansistr_to_widechararray[len],(arraysize-len)*SizeOf(WideChar),0);
 end;
-{$endif hascompilerproc}
 
-{$ifdef hascompilerproc}
 function fpc_shortstr_to_widechararray(arraysize: SizeInt; const src: ShortString): fpc_big_widechararray;[public,alias: 'FPC_SHORTSTR_TO_WIDECHARARRAY']; compilerproc;
 var
   len: longint;
@@ -693,8 +554,7 @@ begin
   fillchar(fpc_shortstr_to_widechararray[len],(arraysize-len)*SizeOf(WideChar),0);
 end;
 
-{$endif hascompilerproc}
-Function fpc_WideStr_Compare(const S1,S2 : WideString): SizeInt;[Public,Alias : 'FPC_WIDESTR_COMPARE']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_WideStr_Compare(const S1,S2 : WideString): SizeInt;[Public,Alias : 'FPC_WIDESTR_COMPARE']; compilerproc;
 {
   Compares 2 WideStrings;
   The result is
@@ -721,20 +581,20 @@ begin
 end;
 
 
-Procedure fpc_WideStr_CheckZero(p : pointer);[Public,Alias : 'FPC_WIDESTR_CHECKZERO']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_CheckZero(p : pointer);[Public,Alias : 'FPC_WIDESTR_CHECKZERO']; compilerproc;
 begin
   if p=nil then
     HandleErrorFrame(201,get_frame);
 end;
 
 
-Procedure fpc_WideStr_CheckRange(len,index : SizeInt);[Public,Alias : 'FPC_WIDESTR_RANGECHECK']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_CheckRange(len,index : SizeInt);[Public,Alias : 'FPC_WIDESTR_RANGECHECK']; compilerproc;
 begin
   if (index>len) or (Index<1) then
     HandleErrorFrame(201,get_frame);
 end;
 
-Procedure fpc_WideStr_SetLength (Var S : WideString; l : SizeInt);[Public,Alias : 'FPC_WIDESTR_SETLENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_SetLength (Var S : WideString; l : SizeInt);[Public,Alias : 'FPC_WIDESTR_SETLENGTH']; compilerproc;
 {
   Sets The length of string S to L.
   Makes sure S is unique, and contains enough room.
@@ -830,7 +690,7 @@ procedure WideCharToStrVar(S : PWideChar;var Dest : AnsiString);
 
 
 
-Function fpc_widestr_Unique(Var S : Pointer): Pointer; [Public,Alias : 'FPC_WIDESTR_UNIQUE']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_widestr_Unique(Var S : Pointer): Pointer; [Public,Alias : 'FPC_WIDESTR_UNIQUE']; compilerproc;
 {
   Make sure reference count of S is 1,
   using copy-on-write semantics.
@@ -1062,7 +922,7 @@ begin
 end;
 
 
-Function fpc_Val_Real_WideStr(Const S : WideString; Var Code : ValSInt): ValReal; [public, alias:'FPC_VAL_REAL_WIDESTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_Real_WideStr(Const S : WideString; Var Code : ValSInt): ValReal; [public, alias:'FPC_VAL_REAL_WIDESTR']; compilerproc;
 Var
   SS : String;
 begin
@@ -1077,7 +937,7 @@ begin
 end;
 
 
-Function fpc_Val_UInt_WideStr (Const S : WideString; Var Code : ValSInt): ValUInt; [public, alias:'FPC_VAL_UINT_WIDESTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_UInt_WideStr (Const S : WideString; Var Code : ValSInt): ValUInt; [public, alias:'FPC_VAL_UINT_WIDESTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -1092,7 +952,7 @@ begin
 end;
 
 
-Function fpc_Val_SInt_WideStr (DestSize: SizeInt; Const S : WideString; Var Code : ValSInt): ValSInt; [public, alias:'FPC_VAL_SINT_WIDESTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_SInt_WideStr (DestSize: SizeInt; Const S : WideString; Var Code : ValSInt): ValSInt; [public, alias:'FPC_VAL_SINT_WIDESTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -1109,7 +969,7 @@ end;
 
 {$ifndef CPU64}
 
-Function fpc_Val_qword_WideStr (Const S : WideString; Var Code : ValSInt): qword; [public, alias:'FPC_VAL_QWORD_WIDESTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_qword_WideStr (Const S : WideString; Var Code : ValSInt): qword; [public, alias:'FPC_VAL_QWORD_WIDESTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -1124,7 +984,7 @@ begin
 end;
 
 
-Function fpc_Val_int64_WideStr (Const S : WideString; Var Code : ValSInt): Int64; [public, alias:'FPC_VAL_INT64_WIDESTR']; {$ifdef hascompilerproc} compilerproc; {$endif}
+Function fpc_Val_int64_WideStr (Const S : WideString; Var Code : ValSInt): Int64; [public, alias:'FPC_VAL_INT64_WIDESTR']; compilerproc;
 Var
   SS : ShortString;
 begin
@@ -1141,7 +1001,7 @@ end;
 {$endif CPU64}
 
 
-procedure fpc_WideStr_Float(d : ValReal;len,fr,rt : SizeInt;var s : WideString);{$ifdef hascompilerproc} compilerproc; {$endif}
+procedure fpc_WideStr_Float(d : ValReal;len,fr,rt : SizeInt;var s : WideString);compilerproc;
 var
   ss : shortstring;
 begin
@@ -1151,9 +1011,9 @@ end;
 
 
 {$ifdef STR_USES_VALINT}
-Procedure fpc_WideStr_SInt(v : ValSint; Len : SizeInt; Var S : WideString);{$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_SInt(v : ValSint; Len : SizeInt; Var S : WideString);compilerproc;
 {$else}
-Procedure fpc_WideStr_Longint(v : Longint; Len : SizeInt; Var S : WideString);{$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_Longint(v : Longint; Len : SizeInt; Var S : WideString);compilerproc;
 {$endif}
 Var
   SS : ShortString;
@@ -1164,9 +1024,9 @@ end;
 
 
 {$ifdef STR_USES_VALINT}
-Procedure fpc_WideStr_UInt(v : ValUInt;Len : SizeInt; Var S : WideString);{$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_UInt(v : ValUInt;Len : SizeInt; Var S : WideString);compilerproc;
 {$else}
-Procedure fpc_WideStr_Longword(v : Longword;Len : SizeInt; Var S : WideString);{$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_Longword(v : Longword;Len : SizeInt; Var S : WideString);compilerproc;
 {$endif}
 Var
   SS : ShortString;
@@ -1178,7 +1038,7 @@ end;
 
 {$ifndef CPU64}
 
-Procedure fpc_WideStr_Int64(v : Int64; Len : SizeInt; Var S : WideString);{$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_Int64(v : Int64; Len : SizeInt; Var S : WideString);compilerproc;
 Var
   SS : ShortString;
 begin
@@ -1187,7 +1047,7 @@ begin
 end;
 
 
-Procedure fpc_WideStr_Qword(v : Qword;Len : SizeInt; Var S : WideString);{$ifdef hascompilerproc} compilerproc; {$endif}
+Procedure fpc_WideStr_Qword(v : Qword;Len : SizeInt; Var S : WideString);compilerproc;
 Var
   SS : ShortString;
 begin

rtl/powerpc/int64p.inc

@@ -14,7 +14,7 @@
  **********************************************************************}
 
 {$define FPC_SYSTEM_HAS_DIV_QWORD}
-    function fpc_div_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_DIV_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_div_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_DIV_QWORD']; compilerproc;
       { from the ppc compiler writers guide }
       assembler; nostackframe;
       asm
@@ -126,7 +126,7 @@
 {$define FPC_SYSTEM_HAS_MOD_QWORD}
     function int_div_qword(n,z : qword) : qword;external name 'FPC_DIV_QWORD';
 
-    function fpc_mod_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_MOD_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mod_qword(n,z : qword) : qword;assembler;[public,alias: 'FPC_MOD_QWORD']; compilerproc;
       assembler;
       var
         oldlr: pointer;
@@ -144,7 +144,7 @@
     { multiplies two qwords
       the longbool for checkoverflow avoids a misaligned stack
     }
-    function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;[public,alias: 'FPC_MUL_QWORD']; {$ifdef hascompilerproc} compilerproc; {$endif}
+    function fpc_mul_qword(f1,f2 : qword;checkoverflow : longbool) : qword;[public,alias: 'FPC_MUL_QWORD']; compilerproc;
       assembler; nostackframe;
       asm
         // (r3:r4) = (r3:r4) * (r5:r6),  checkoverflow is in r7

rtl/powerpc/math.inc

@@ -163,13 +163,9 @@ const
 (*
 {$ifndef FPC_SYSTEM_HAS_ROUND}
     {$define FPC_SYSTEM_HAS_ROUND}
-{$ifdef hascompilerproc}
     function round(d : extended) : int64;{$ifndef INTERNCONSTINTF}[internconst:fpc_in_const_round, external name 'FPC_ROUND'];{$endif}
 
-    function fpc_round(d : extended) : int64;assembler;[public, alias:'FPC_ROUND'];{$ifdef hascompilerproc}compilerproc;{$endif hascompilerproc}
-{$else}
-    function round(d : extended) : int64;assembler;{$ifndef INTERNCONSTINTF}[internconst:fpc_in_const_round];{$endif}
-{$endif hascompilerproc}
+    function fpc_round(d : extended) : int64;assembler;[public, alias:'FPC_ROUND'];compilerproc;
       { exactly the same as trunc, except that one fctiwz has become fctiw }
       { input: d in fr1      }
       { output: result in r3 }

rtl/powerpc/powerpc.inc

@@ -1020,7 +1020,7 @@ assembler; nostackframe;
 
 {$ifndef FPC_SYSTEM_HAS_FPC_PCHAR_LENGTH}
 {$define FPC_SYSTEM_HAS_FPC_PCHAR_LENGTH}
-function fpc_pchar_length(p:pchar):longint;assembler;[public,alias:'FPC_PCHAR_LENGTH']; {$ifdef hascompilerproc} compilerproc; {$endif} nostackframe;
+function fpc_pchar_length(p:pchar):longint;assembler;[public,alias:'FPC_PCHAR_LENGTH']; compilerproc; nostackframe;
 {$include strlen.inc}
 {$endif FPC_SYSTEM_HAS_FPC_PCHAR_LENGTH}
 

rtl/x86_64/math.inc

@@ -235,13 +235,9 @@
 {$ifdef internconstintf}
     function fpc_round_real(d : ValReal) : int64;assembler;compilerproc;
 {$else}
-  {$ifdef hascompilerproc}
     function round(d : extended) : int64;[internconst:fpc_in_const_round, external name 'FPC_ROUND'];
 
-    function fpc_round(d : extended) : int64;assembler;[public, alias:'FPC_ROUND'];{$ifdef hascompilerproc}compilerproc;{$endif hascompilerproc}
-  {$else}
-    function round(d : extended) : int64;assembler;[internconst:fpc_in_const_round];
-  {$endif hascompilerproc}
+    function fpc_round(d : extended) : int64;assembler;[public, alias:'FPC_ROUND'];compilerproc;
 {$endif}
       var
         oldcw,