* fixed skipping of parameter registers for ppc/aix in case a parameter

    has to be passed on the stack before all registesters are used up
  * fixed calculation of stack offsets for ppc/aix abi for small records, 
    arrays and ordinals passed on the stack after all registers are used
  + test for all of the above

git-svn-id: trunk@3166 -

.gitattributes

@@ -5412,6 +5412,7 @@ tests/test/cg/obj/darwin/i386/tcext4.o -text
 tests/test/cg/obj/darwin/powerpc/ctest.o -text
 tests/test/cg/obj/darwin/powerpc/tcext3.o -text
 tests/test/cg/obj/darwin/powerpc/tcext4.o -text
+tests/test/cg/obj/darwin/powerpc/tcext5.o -text
 tests/test/cg/obj/freebsd/i386/ctest.o -text
 tests/test/cg/obj/freebsd/i386/tcext3.o -text
 tests/test/cg/obj/freebsd/i386/tcext4.o -text
@@ -5440,6 +5441,7 @@ tests/test/cg/obj/solaris/sparc/tcext3.o -text
 tests/test/cg/obj/solaris/sparc/tcext4.o -text
 tests/test/cg/obj/tcext3.c -text
 tests/test/cg/obj/tcext4.c -text
+tests/test/cg/obj/tcext5.c -text
 tests/test/cg/obj/win32/i386/ctest.o -text
 tests/test/cg/obj/win32/i386/tcext3.o -text
 tests/test/cg/obj/win32/i386/tcext4.o -text
@@ -5478,6 +5480,7 @@ tests/test/cg/tcalext.pp svneol=native#text/plain
 tests/test/cg/tcalext2.pp svneol=native#text/plain
 tests/test/cg/tcalext3.pp -text
 tests/test/cg/tcalext4.pp -text
+tests/test/cg/tcalext5.pp svneol=native#text/plain
 tests/test/cg/tcalfun1.pp svneol=native#text/plain
 tests/test/cg/tcalfun2.pp svneol=native#text/plain
 tests/test/cg/tcalfun3.pp svneol=native#text/plain

compiler/powerpc/cpupara.pas

@@ -429,7 +429,7 @@ unit cpupara;
               hp.paraloc[side].size:=paracgsize;
               hp.paraloc[side].intsize:=paralen;
               if (target_info.abi = abi_powerpc_aix) and
-                 (paradef.deftype = recorddef) then
+                 (paradef.deftype in [recorddef,arraydef]) then
                 hp.paraloc[side].composite:=true;
 {$ifndef cpu64bit}
               if (target_info.abi=abi_powerpc_sysv) and
@@ -511,8 +511,20 @@ unit cpupara;
                            paraloc^.reference.index:=NR_R12;
                            tppcprocinfo(current_procinfo).needs_frame_pointer := true;
                          end;
-                       paraloc^.reference.offset:=stack_offset;
+                       
+                       if (target_info.abi = abi_powerpc_aix) and
+                          (hp.paraloc[side].intsize < 3) then
+                           paraloc^.reference.offset:=stack_offset+(4-paralen)
+                       else
+                         paraloc^.reference.offset:=stack_offset;
+
                        inc(stack_offset,align(paralen,4));
+                       while (paralen > 0) and
+                             (nextintreg < RS_R11) do
+                          begin
+                            inc(nextintreg);
+                            dec(paralen,sizeof(aint));
+                          end;
                        paralen := 0;
                     end;
                 end;

tests/test/cg/obj/tcext5.c

@@ -0,0 +1,459 @@
+#include <stdint.h>
+
+struct struct_arr1 {
+  int8_t v[1];
+  };
+
+struct struct_arr2 {
+  int8_t v[2];
+  };
+
+struct struct_arr3 {
+  int8_t v[3];
+  };
+
+struct struct_arr4 {
+  int8_t v[4];
+  };
+
+struct struct_arr5 {
+  int8_t v[5];
+  };
+
+struct struct_arr6 {
+  int8_t v[6];
+  };
+
+struct struct_arr7 {
+  int8_t v[7];
+  };
+  
+struct struct_arr8 {
+  int8_t v[8];
+  };
+  
+struct struct_arr9 {
+  int8_t v[9];
+  };
+
+struct struct_arr10 {
+  int8_t v[10];
+  };
+
+struct struct_arr11 {
+  int8_t v[11];
+  };
+
+struct struct_arr15 {
+  int8_t v[15];
+  };
+
+struct struct_arr16 {
+  int8_t v[16];
+  };
+
+struct struct_arr17{
+  int8_t v[17];
+  };
+
+
+struct struct_arr27 {
+  int8_t v[27];
+  };
+
+struct struct_arr31 {
+  int8_t v[31];
+  };
+
+struct struct_arr32 {
+  int8_t v[32];
+  };
+
+struct struct_arr33 {
+  int8_t v[33];
+  };
+
+
+struct struct1 {
+  int8_t v;
+  };
+
+struct struct2 {
+  int16_t v;
+  };
+
+
+struct struct3 {
+  int16_t v1;
+  int8_t v2;
+  };
+
+struct struct4 {
+  int32_t v;
+  };
+
+struct struct5 {
+  int32_t v1;
+  int8_t v2;
+  };
+
+struct struct6 {
+  int32_t v1;
+  int16_t v2;
+  };
+
+struct struct7 {
+  int32_t v1;
+  int16_t v2;
+  int8_t v3;
+  };
+
+struct struct8 {
+  int64_t v;
+  };
+
+struct struct9 {
+  int64_t v1;
+  int8_t v2;
+  };
+
+struct struct10 {
+  int64_t v1;
+  int16_t v2;
+  };
+
+struct struct11 {
+  int64_t v1;
+  int16_t v2;
+  int8_t v3;
+  };
+
+struct struct12 {
+  int64_t v1;
+  int32_t v2;
+  };
+
+struct struct13 {
+  int64_t v1;
+  int32_t v2;
+  int8_t v3;
+  };
+
+struct struct14 {
+  int64_t v1;
+  int32_t v2;
+  int16_t v3;
+  };
+
+struct struct15 {
+  int64_t v1;
+  int32_t v2;
+  int16_t v3;
+  int8_t v4;
+  };
+
+struct struct16 {
+  int64_t v1;
+  int64_t v2;
+  };
+
+struct struct31 {
+  int64_t v1;
+  int64_t v2;
+  int64_t v3;
+  int32_t v4;
+  int16_t v5;
+  int8_t v6;
+  };
+
+int64_t pass1(struct struct1 s, char c) {
+  if (c != 1)
+    return -1;
+  return s.v;
+}
+
+int64_t pass2(struct struct2 s, char c) {
+  if (c != 2)
+    return -1;
+  return s.v;
+}
+
+int64_t pass3(struct struct3 s, char c) {
+  if (c != 3)
+    return -1;
+  return s.v1 + s.v2;
+}
+
+int64_t pass4(struct struct4 s, char c) {
+  if (c != 4)
+    return -1;
+  return s.v;
+}
+
+int64_t pass5(struct struct5 s, char c) {
+  if (c != 5)
+    return -1;
+  return s.v1 + s.v2;
+}
+
+int64_t pass6(struct struct6 s, char c) {
+  if (c != 6)
+    return -1;
+  return s.v1 + s.v2;
+}
+
+int64_t pass7(struct struct7 s, char c) {
+  if (c != 7)
+    return -1;
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass8(struct struct8 s, char c) {
+  if (c != 8)
+    return -1;
+  return s.v;
+}
+
+int64_t pass9(struct struct9 s, char c) {
+  if (c != 9)
+    return -1;
+  return s.v1 + s.v2;
+}
+
+int64_t pass10(struct struct10 s, char c) {
+  if (c != 10)
+    return -1;
+  return s.v1 + s.v2;
+}
+
+int64_t pass11(struct struct11 s, char c) {
+  if (c != 11)
+    return -1;
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass12(struct struct12 s, char c) {
+  if (c != 12)
+    return -1;
+  return s.v1 + s.v2;
+}
+
+int64_t pass13(struct struct13 s, char c) {
+  if (c != 13)
+    return -1;
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass14(struct struct14 s, char c) {
+  if (c != 14)
+    return -1;
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass15(struct struct15 s, char c) {
+  if (c != 15)
+    return -1;
+  return s.v1 + s.v2 + s.v3 + s.v4;
+}
+
+int64_t pass16(struct struct16 s, char c) {
+  if (c != 16)
+    return -1;
+  return s.v1 + s.v2;
+}
+
+int64_t pass31(struct struct31 s, char c) {
+  if (c != 31)
+    return -1;
+  return s.v1 + s.v2 + s.v3 + s.v4 + s.v5 + s.v6;
+}
+
+int64_t pass311(struct struct31 s, struct struct1 s1, char c) {
+  if (c != 32)
+    return -1;
+  return s1.v;
+}
+
+int64_t pass312(struct struct31 s, struct struct2 s2, char c) {
+  if (c != 33)
+    return -1;
+  return s2.v;
+}
+
+int64_t pass313(struct struct31 s, struct struct3 s3, char c) {
+  if (c != 34)
+    return -1;
+  return s3.v1 + s3.v2;
+}
+
+int64_t pass11db10db(struct struct11 s11, double d1, uint8_t b1, struct struct10 s10, double d2, uint8_t b2) {
+  if ((b1 != 35) ||
+      (b2 != 36) ||
+      ((d1 - 12345.678) > 0.001) ||
+      ((d2 - 98765.453) > 0.001))
+    return -1;
+  return s10.v1 + s10.v2;
+}
+
+
+int64_t pass_arr1(struct struct_arr1 s, char c) {
+  int result = 0, i;
+  if (c != 101)
+    return -1;
+  for (i = 0; i < 1; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr2(struct struct_arr2 s, char c) {
+  int result = 0, i;
+  if (c != 102)
+    return -1;
+  for (i = 0; i < 2; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr3(struct struct_arr3 s, char c) {
+  int result = 0, i;
+  if (c != 103)
+    return -1;
+  for (i = 0; i < 3; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr4(struct struct_arr4 s, char c) {
+  int result = 0, i;
+  if (c != 104)
+    return -1;
+  for (i = 0; i < 4; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr5(struct struct_arr5 s, char c) {
+  int result = 0, i;
+  if (c != 105)
+    return -1;
+  for (i = 0; i < 5; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr6(struct struct_arr6 s, char c) {
+  int result = 0, i;
+  if (c != 106)
+    return -1;
+  for (i = 0; i < 6; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr7(struct struct_arr7 s, char c) {
+  int result = 0, i;
+  if (c != 107)
+    return -1;
+  for (i = 0; i < 7; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr8(struct struct_arr8 s, char c) {
+  int result = 0, i;
+  if (c != 108)
+    return -1;
+  for (i = 0; i < 8; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr9(struct struct_arr9 s, char c) {
+  int result = 0, i;
+  if (c != 109)
+    return -1;
+  for (i = 0; i < 9; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr10(struct struct_arr10 s, char c) {
+  int result = 0, i;
+  if (c != 110)
+    return -1;
+  for (i = 0; i < 10; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr11(struct struct_arr11 s, char c) {
+  int result = 0, i;
+  if (c != 111)
+    return -1;
+  for (i = 0; i < 11; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr15(struct struct_arr15 s, char c) {
+  int result = 0, i;
+  if (c != 115)
+    return -1;
+  for (i = 0; i < 15; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr16(struct struct_arr16 s, char c) {
+  int result = 0, i;
+  if (c != 116)
+    return -1;
+  for (i = 0; i < 16; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr17(struct struct_arr17 s, char c) {
+  int result = 0, i;
+  if (c != 117)
+    return -1;
+  for (i = 0; i < 17; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr27(struct struct_arr27 s, char c) {
+  int result = 0, i;
+  if (c != 127)
+    return -1;
+  for (i = 0; i < 27; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr31(struct struct_arr31 s, unsigned char c) {
+  int result = 0, i;
+  if (c != 131)
+    return -1;
+  for (i = 0; i < 31; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr32(struct struct_arr32 s, unsigned char c) {
+  int result = 0, i;
+  if (c != 132)
+    return -1;
+  for (i = 0; i < 32; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr33(struct struct_arr33 s, unsigned char c) {
+  int result = 0, i;
+  if (c != 133)
+    return -1;
+  for (i = 0; i < 33; i++)
+    result += s.v[i];
+  return result;
+}

tests/test/cg/tcalext5.pp

@@ -0,0 +1,626 @@
+{ Tests passing of different records by value to C methods. 
+ One type of these records has one field which is a simple array of bytes,
+ the other consists of a few fields of atomic size.
+ 
+ Note that it does not only test a single field of these records, but all
+ by comparing the sum of the field values with the sum returned by the
+ C function.
+}
+program calext3;
+{$MODE DELPHI}
+
+type
+  int8_t = shortint;
+  pint8_t = ^int8_t;
+  int16_t = smallint;
+  int32_t = longint;
+  int64_t = int64;
+
+var
+  success : boolean;
+
+{$packrecords c}
+
+type
+  struct_arr1 = record
+    v : array[0..0] of int8_t;
+  end;
+
+  struct_arr2 = record
+    v : array[0..1] of int8_t;
+  end;
+
+  struct_arr3 = record
+    v : array[0..2] of int8_t;
+  end;
+
+  struct_arr4 = record
+    v : array[0..3] of int8_t;
+  end;
+
+  struct_arr5 = record
+    v : array[0..4] of int8_t;
+  end;
+
+  struct_arr6 = record
+    v : array[0..5] of int8_t;
+  end;
+
+  struct_arr7 = record
+    v : array[0..6] of int8_t;
+  end;
+
+  struct_arr8 = record
+    v : array[0..7] of int8_t;
+  end;
+
+  struct_arr9 = record
+    v : array[0..8] of int8_t;
+  end;
+
+  struct_arr10 = record
+    v : array[0..9] of int8_t;
+  end;
+
+  struct_arr11 = record
+    v : array[0..10] of int8_t;
+  end;
+
+  struct_arr15 = record
+    v : array[0..14] of int8_t;
+  end;
+
+  struct_arr16 = record
+    v : array[0..15] of int8_t;
+  end;
+
+  struct_arr17 = record
+    v : array[0..16] of int8_t;
+  end;
+
+
+  struct_arr27 = record
+    v : array[0..26] of int8_t;
+  end;
+
+  struct_arr31 = record
+    v : array[0..30] of int8_t;
+  end;
+
+  struct_arr32 = record
+    v : array[0..31] of int8_t;
+  end;
+
+  struct_arr33 = record
+    v : array[0..32] of int8_t;
+  end;
+
+
+  struct1 = record
+    v : int8_t;
+  end;
+
+  struct2 = record
+    v : int16_t;
+  end;
+
+  struct3 = record
+    v1 : int16_t;
+    v2 : int8_t;
+  end;
+
+  struct4 = record
+    v : int32_t;
+  end;
+
+  struct5 = record
+    v1 : int32_t;
+    v2 : int8_t;
+  end;
+
+  struct6 = record
+    v1 : int32_t;
+    v2 : int16_t;
+  end;
+  
+  struct7 = record
+    v1 : int32_t;
+    v2 : int16_t;
+    v3 : int8_t;
+  end;
+
+  struct8 = record
+    v : int64_t
+  end;
+
+  struct9 = record
+    v1 : int64_t;
+    v2 : int8_t;
+  end;
+
+  struct10 = record
+    v1 : int64_t;
+    v2 : int16_t;
+  end;
+
+  struct11 = record
+    v1 : int64_t;
+    v2 : int16_t;
+    v3 : int8_t;
+  end;
+
+  struct12 = record
+    v1 : int64_t;
+    v2 : int32_t;
+  end;
+
+  struct13 = record
+    v1 : int64_t;
+    v2 : int32_t;
+    v3 : int8_t;
+  end;
+
+  struct14 = record
+    v1 : int64_t;
+    v2 : int32_t;
+    v3 : int16_t;
+  end;
+  
+  struct15 = record 
+    v1 : int64_t;
+    v2 : int32_t;
+    v3 : int16_t;
+    v4 : int8_t;
+  end;
+
+  struct16 = record
+    v1 : int64_t;
+    v2 : int64_t;
+  end;
+
+  struct31 = record
+    v1 : int64_t;
+    v2 : int64_t;
+    v3 : int64_t;
+    v4 : int32_t;
+    v5 : int16_t;
+    v6 : int8_t;
+  end;
+
+procedure fill(var mem; size : integer);
+var
+  i : Integer;
+  p : pint8_t;
+begin
+  p := @mem;
+  for i := 0 to size-1 do begin
+    p^ := random(255)+1;
+    inc(p);
+  end;
+end;
+
+procedure verify(val1, val2 : int64_t; nr : Integer);
+begin
+  success := success and (val1 = val2);
+  Write('Testing test ', nr , ', was ', val1, ', should be ', val2, '...');
+  if (val1 = val2) then
+    WriteLn('Success.')
+  else
+    WriteLn('Failed');
+end;
+
+function check1(s : struct1) : int64_t;
+begin
+  result := s.v;
+end;
+
+function check2(s : struct2) : int64_t;
+begin
+  result := s.v;
+end;
+
+function check3(s : struct3) : int64_t;
+begin
+  result := s.v1 + s.v2;
+end;
+
+function check4(s : struct4) : int64_t;
+begin
+  result := s.v;
+end;
+
+function check5(s : struct5) : int64_t;
+begin
+  result := s.v1 + s.v2;
+end;
+
+function check6(s : struct6) : int64_t;
+begin
+  result := s.v1 + s.v2;
+end;
+
+function check7(s : struct7) : int64_t;
+begin
+  result := s.v1 + s.v2 + s.v3;
+end;
+
+function check8(s : struct8) : int64_t;
+begin
+  result := s.v;
+end;
+
+function check9(s : struct9) : int64_t;
+begin
+  result := s.v1 + s.v2;
+end;
+
+function check10(s : struct10) : int64_t;
+begin
+  result := s.v1 + s.v2;
+end;
+
+function check11(s : struct11) : int64_t;
+begin
+  result := s.v1 + s.v2 + s.v3;
+end;
+
+function check12(s : struct12) : int64_t;
+begin
+  result := s.v1 + s.v2;
+end;
+
+function check13(s : struct13) : int64_t;
+begin
+  result := s.v1 + s.v2 + s.v3;
+end;
+
+function check14(s : struct14) : int64_t;
+begin
+  result := s.v1 + s.v2 + s.v3;
+end;
+
+function check15(s : struct15) : int64_t;
+begin
+  result := s.v1 + s.v2 + s.v3 + s.v4;
+end;
+
+function check16(s : struct16) : int64_t;
+begin
+  result := s.v1 + s.v2;
+end;
+
+function check31(s : struct31) : int64_t;
+begin
+  result := s.v1 + s.v2 + s.v3 + s.v4 + s.v5 + s.v6;
+end;
+
+
+function check_arr1(s : struct_arr1) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr2(s : struct_arr2) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr3(s : struct_arr3) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr4(s : struct_arr4) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr5(s : struct_arr5) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr6(s : struct_arr6) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr7(s : struct_arr7) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr8(s : struct_arr8) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr9(s : struct_arr9) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr10(s : struct_arr10) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr11(s : struct_arr11) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr15(s : struct_arr15) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr16(s : struct_arr16) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr17(s : struct_arr17) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr27(s : struct_arr27) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr31(s : struct_arr31) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr32(s : struct_arr32) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+function check_arr33(s : struct_arr33) : int64_t;
+var
+  i : int32_t;
+begin
+  result := 0;
+  for i := low(s.v) to high(s.v) do
+    inc(result, s.v[i]);
+end;
+
+{$L tcext5.o}
+function pass1(s : struct1; b: byte) : int64_t; cdecl; external;
+function pass2(s : struct2; b: byte) : int64_t; cdecl; external;
+function pass3(s : struct3; b: byte) : int64_t; cdecl; external;
+function pass4(s : struct4; b: byte) : int64_t; cdecl; external;
+function pass5(s : struct5; b: byte) : int64_t; cdecl; external;
+function pass6(s : struct6; b: byte) : int64_t; cdecl; external;
+function pass7(s : struct7; b: byte) : int64_t; cdecl; external;
+function pass8(s : struct8; b: byte) : int64_t; cdecl; external;
+function pass9(s : struct9; b: byte) : int64_t; cdecl; external;
+function pass10(s : struct10; b: byte) : int64_t; cdecl; external;
+function pass11(s : struct11; b: byte) : int64_t; cdecl; external;
+function pass12(s : struct12; b: byte) : int64_t; cdecl; external;
+function pass13(s : struct13; b: byte) : int64_t; cdecl; external;
+function pass14(s : struct14; b: byte) : int64_t; cdecl; external;
+function pass15(s : struct15; b: byte) : int64_t; cdecl; external;
+function pass31(s : struct31; b: byte) : int64_t; cdecl; external;
+function pass311(s : struct31; s1: struct1; b: byte) : int64_t; cdecl; external;
+function pass312(s : struct31; s2: struct2; b: byte) : int64_t; cdecl; external;
+function pass313(s : struct31; s3: struct3; b: byte) : int64_t; cdecl; external;
+function pass11db10db(s11: struct11; d1: double; b1: byte; s10: struct10; s2: double; b2: byte): int64_t; cdecl; external;
+
+
+function pass_arr1(s : struct_arr1; b: byte) : int64_t; cdecl; external;
+function pass_arr2(s : struct_arr2; b: byte) : int64_t; cdecl; external;
+function pass_arr3(s : struct_arr3; b: byte) : int64_t; cdecl; external;
+function pass_arr4(s : struct_arr4; b: byte) : int64_t; cdecl; external;
+function pass_arr5(s : struct_arr5; b: byte) : int64_t; cdecl; external;
+function pass_arr6(s : struct_arr6; b: byte) : int64_t; cdecl; external;
+function pass_arr7(s : struct_arr7; b: byte) : int64_t; cdecl; external;
+function pass_arr8(s : struct_arr8; b: byte) : int64_t; cdecl; external;
+function pass_arr9(s : struct_arr9; b: byte) : int64_t; cdecl; external;
+function pass_arr10(s : struct_arr10; b: byte) : int64_t; cdecl; external;
+function pass_arr11(s : struct_arr11; b: byte) : int64_t; cdecl; external;
+function pass_arr15(s : struct_arr15; b: byte) : int64_t; cdecl; external;
+function pass_arr16(s : struct_arr16; b: byte) : int64_t; cdecl; external;
+function pass_arr17(s : struct_arr17; b: byte) : int64_t; cdecl; external;
+
+function pass_arr27(s : struct_arr27; b: byte) : int64_t; cdecl; external;
+
+function pass_arr31(s : struct_arr31; b: byte) : int64_t; cdecl; external;
+function pass_arr32(s : struct_arr32; b: byte) : int64_t; cdecl; external;
+function pass_arr33(s : struct_arr33; b: byte) : int64_t; cdecl; external;
+
+
+var
+  sa1 : struct_arr1;
+  sa2 : struct_arr2;
+  sa3 : struct_arr3;
+  sa4 : struct_arr4;
+  sa5 : struct_arr5;
+  sa6 : struct_arr6;
+  sa7 : struct_arr7;
+  sa8 : struct_arr8;
+  sa9 : struct_arr9;
+  sa10 : struct_arr10;
+  sa11 : struct_arr11;
+  sa15 : struct_arr15;
+  sa16 : struct_arr16;
+  sa17 : struct_arr17;
+  sa27 : struct_arr27;
+  sa31 : struct_arr31;
+  sa32 : struct_arr32;
+  sa33 : struct_arr33;
+  
+  s1 : struct1;
+  s2 : struct2;
+  s3 : struct3;
+  s4 : struct4;
+  s5 : struct5;
+  s6 : struct6;
+  s7 : struct7;
+  s8 : struct8;
+  s9 : struct9;
+  s10 : struct10;
+  s11 : struct11;
+  s12 : struct12;
+  s13 : struct13;
+  s14 : struct14;
+  s15 : struct15;
+  s31 : struct31;
+
+begin
+  randseed := 30;
+  success := true;
+  fill(s1, sizeof(s1));
+  fill(s2, sizeof(s2));
+  fill(s3, sizeof(s3));
+  fill(s4, sizeof(s4));
+  fill(s5, sizeof(s5));
+  fill(s6, sizeof(s6));
+  fill(s7, sizeof(s7));
+  fill(s8, sizeof(s8));
+  fill(s9, sizeof(s9));
+  fill(s10, sizeof(s10));
+  fill(s11, sizeof(s11));
+  fill(s12, sizeof(s12));
+  fill(s13, sizeof(s13));
+  fill(s14, sizeof(s14));
+  fill(s15, sizeof(s15));
+  fill(s31, sizeof(s31));
+
+  fill(sa1, sizeof(sa1));
+  fill(sa2, sizeof(sa2));
+  fill(sa3, sizeof(sa3));
+  fill(sa4, sizeof(sa4));
+  fill(sa5, sizeof(sa5));
+  fill(sa6, sizeof(sa6));
+  fill(sa7, sizeof(sa7));
+  fill(sa8, sizeof(sa8));
+  fill(sa9, sizeof(sa9));
+  fill(sa10, sizeof(sa10));
+  fill(sa11, sizeof(sa11));
+  fill(sa15, sizeof(sa15));
+  fill(sa16, sizeof(sa16));
+  fill(sa17, sizeof(sa17));
+  fill(sa27, sizeof(sa27));
+  fill(sa31, sizeof(sa31));
+  fill(sa32, sizeof(sa32));
+  fill(sa33, sizeof(sa33));
+
+
+  verify(pass1(s1,1), check1(s1), 1);
+  verify(pass2(s2,2), check2(s2), 2);
+  verify(pass3(s3,3), check3(s3), 3);
+  verify(pass4(s4,4), check4(s4), 4);
+  verify(pass5(s5,5), check5(s5), 5);
+  verify(pass6(s6,6), check6(s6), 6);
+  verify(pass7(s7,7), check7(s7), 7);
+  verify(pass8(s8,8), check8(s8), 8);
+  verify(pass9(s9,9), check9(s9), 9);
+  verify(pass10(s10,10), check10(s10), 10);
+  verify(pass11(s11,11), check11(s11), 11);
+  verify(pass12(s12,12), check12(s12), 12);
+  verify(pass13(s13,13), check13(s13), 13);
+  verify(pass14(s14,14), check14(s14), 14);
+  verify(pass15(s15,15), check15(s15), 15);
+  verify(pass31(s31,31), check31(s31), 31);
+  { special cases for ppc/aix abi }
+  verify(pass311(s31,s1,32), check1(s1), 32);
+  verify(pass312(s31,s2,33), check2(s2), 33);
+  verify(pass313(s31,s3,34), check3(s3), 34);
+  verify(pass11db10db(s11,12345.678,35,s10,98745.453,36), check10(s10), 35);
+
+  verify(pass_arr1(sa1,101), check_arr1(sa1), 101);
+  verify(pass_arr2(sa2,102), check_arr2(sa2), 102);
+  verify(pass_arr3(sa3,103), check_arr3(sa3), 103);
+  verify(pass_arr4(sa4,104), check_arr4(sa4), 104);
+  verify(pass_arr5(sa5,105), check_arr5(sa5), 105);
+  verify(pass_arr6(sa6,106), check_arr6(sa6), 106);
+  verify(pass_arr7(sa7,107), check_arr7(sa7), 107);
+  verify(pass_arr8(sa8,108), check_arr8(sa8), 108);
+  verify(pass_arr9(sa9,109), check_arr9(sa9), 109);
+  verify(pass_arr10(sa10,110), check_arr10(sa10), 110);
+  verify(pass_arr11(sa11,111), check_arr11(sa11), 111);
+  verify(pass_arr15(sa15,115), check_arr15(sa15), 115);
+  verify(pass_arr16(sa16,116), check_arr16(sa16), 116);
+  verify(pass_arr17(sa17,117), check_arr17(sa17), 117);
+  verify(pass_arr27(sa27,127), check_arr27(sa27), 127);
+
+  verify(pass_arr31(sa31,131), check_arr31(sa31), 131);
+  verify(pass_arr32(sa32,132), check_arr32(sa32), 132);
+  verify(pass_arr33(sa33,133), check_arr33(sa33), 133);
+
+  if (not success) then
+    halt(1);
+end.