* new additional C parameter passing test programs

* finally added powerpc64/linux C object files to repository

git-svn-id: trunk@1982 -

.gitattributes

@@ -5360,12 +5360,19 @@ tests/test/cg/obj/linux/arm/ctest.o -text
 tests/test/cg/obj/linux/i386/ctest.o -text
 tests/test/cg/obj/linux/m68k/ctest.o -text
 tests/test/cg/obj/linux/powerpc/ctest.o -text
+tests/test/cg/obj/linux/powerpc/tcext3.o -text
+tests/test/cg/obj/linux/powerpc/tcext4.o -text
+tests/test/cg/obj/linux/powerpc64/ctest.o -text
+tests/test/cg/obj/linux/powerpc64/tcext3.o -text
+tests/test/cg/obj/linux/powerpc64/tcext4.o -text
 tests/test/cg/obj/linux/sparc/ctest.o -text
 tests/test/cg/obj/linux/x86_64/ctest.o -text
 tests/test/cg/obj/macos/powerpc/ctest.o -text
 tests/test/cg/obj/netbsd/m68k/ctest.o -text
 tests/test/cg/obj/os2/i386/ctest.o -text
 tests/test/cg/obj/readme.txt svneol=native#text/plain
+tests/test/cg/obj/tcext3.c -text
+tests/test/cg/obj/tcext4.c -text
 tests/test/cg/obj/win32/i386/ctest.o -text
 tests/test/cg/ptest.pp svneol=native#text/plain
 tests/test/cg/taddbool.pp svneol=native#text/plain
@@ -5394,6 +5401,8 @@ tests/test/cg/tcalcst8.pp svneol=native#text/plain
 tests/test/cg/tcalcst9.pp svneol=native#text/plain
 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/tcalfun1.pp svneol=native#text/plain
 tests/test/cg/tcalfun2.pp svneol=native#text/plain
 tests/test/cg/tcalfun3.pp svneol=native#text/plain

tests/Makefile

@@ -1,5 +1,5 @@
 #
-# Don't edit, this file is generated by FPCMake Version 2.0.0 [2005/11/20]
+# Don't edit, this file is generated by FPCMake Version 2.0.0 [2005/12/10]
 #
 default: allexectests
 MAKEFILETARGETS=i386-linux i386-go32v2 i386-win32 i386-os2 i386-freebsd i386-beos i386-netbsd i386-solaris i386-qnx i386-netware i386-openbsd i386-wdosx i386-emx i386-watcom i386-netwlibc i386-wince m68k-linux m68k-freebsd m68k-netbsd m68k-amiga m68k-atari m68k-openbsd m68k-palmos powerpc-linux powerpc-netbsd powerpc-macos powerpc-darwin powerpc-morphos sparc-linux sparc-netbsd sparc-solaris x86_64-linux x86_64-freebsd x86_64-win64 arm-linux arm-wince powerpc64-linux
@@ -1380,6 +1380,8 @@ units:
 	$(MAKE) -C units FPC_VERSION= FPC=$(TEST_FPC) CPU_TARGET=$(TEST_CPU_TARGET) OS_TARGET=$(TEST_OS_TARGET) OPT="$(TEST_OPT)" CCOMPILER=$(TEST_CCOMPILER) BINUTILSPREFIX=$(TEST_BINUTILSPREFIX)
 copyfiles: $(TEST_OUTPUTDIR)
 	$(COPY) test/cg/obj/$(TEST_OS_TARGET)/$(TEST_CPU_TARGET)/ctest.o test/cg
+	$(COPY) test/cg/obj/$(TEST_OS_TARGET)/$(TEST_CPU_TARGET)/tcext3.o test/cg
+	$(COPY) test/cg/obj/$(TEST_OS_TARGET)/$(TEST_CPU_TARGET)/tcext4.o test/cg
 	-$(MKDIRTREE) $(TEST_OUTPUTDIR)/test/units/system
 	$(COPY) test/units/system/test*.txt $(TEST_OUTPUTDIR)/test/units/system
 testprep: testprep-stamp.$(TEST_FULL_TARGET)

tests/Makefile.fpc

@@ -148,11 +148,13 @@ units:
         $(MAKE) -C units FPC_VERSION= FPC=$(TEST_FPC) CPU_TARGET=$(TEST_CPU_TARGET) OS_TARGET=$(TEST_OS_TARGET) OPT="$(TEST_OPT)" CCOMPILER=$(TEST_CCOMPILER) BINUTILSPREFIX=$(TEST_BINUTILSPREFIX)
 
 ################################
-# Copy test environment dependent files ctest.o to test/cg etc
+# Copy test environment dependent files ctest.o, cext3.o, cext4.o to test/cg etc
 #
 
 copyfiles: $(TEST_OUTPUTDIR)
         $(COPY) test/cg/obj/$(TEST_OS_TARGET)/$(TEST_CPU_TARGET)/ctest.o test/cg
+        $(COPY) test/cg/obj/$(TEST_OS_TARGET)/$(TEST_CPU_TARGET)/tcext3.o test/cg
+        $(COPY) test/cg/obj/$(TEST_OS_TARGET)/$(TEST_CPU_TARGET)/tcext4.o test/cg
         -$(MKDIRTREE) $(TEST_OUTPUTDIR)/test/units/system
         $(COPY) test/units/system/test*.txt $(TEST_OUTPUTDIR)/test/units/system
 

tests/test/cg/obj/tcext3.c

@@ -0,0 +1,361 @@
+#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) {
+  return s.v;
+}
+
+int64_t pass2(struct struct2 s) {
+  return s.v;
+}
+
+int64_t pass3(struct struct3 s) {
+  return s.v1 + s.v2;
+}
+
+int64_t pass4(struct struct4 s) {
+  return s.v;
+}
+
+int64_t pass5(struct struct5 s) {
+  return s.v1 + s.v2;
+}
+
+int64_t pass6(struct struct6 s) {
+  return s.v1 + s.v2;
+}
+
+int64_t pass7(struct struct7 s) {
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass8(struct struct8 s) {
+  return s.v;
+}
+
+int64_t pass9(struct struct9 s) {
+  return s.v1 + s.v2;
+}
+
+int64_t pass10(struct struct10 s) {
+  return s.v1 + s.v2;
+}
+
+int64_t pass11(struct struct11 s) {
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass12(struct struct12 s) {
+  return s.v1 + s.v2;
+}
+
+int64_t pass13(struct struct13 s) {
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass14(struct struct14 s) {
+  return s.v1 + s.v2 + s.v3;
+}
+
+int64_t pass15(struct struct15 s) {
+  return s.v1 + s.v2 + s.v3 + s.v4;
+}
+
+int64_t pass16(struct struct16 s) {
+  return s.v1 + s.v2;
+}
+
+int64_t pass31(struct struct31 s) {
+  return s.v1 + s.v2 + s.v3 + s.v4 + s.v5 + s.v6;
+}
+
+int64_t pass_arr1(struct struct_arr1 s) {
+  int result = 0, i;
+  for (i = 0; i < 1; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr2(struct struct_arr2 s) {
+  int result = 0, i;
+  for (i = 0; i < 2; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr3(struct struct_arr3 s) {
+  int result = 0, i;
+  for (i = 0; i < 3; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr4(struct struct_arr4 s) {
+  int result = 0, i;
+  for (i = 0; i < 4; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr5(struct struct_arr5 s) {
+  int result = 0, i;
+  for (i = 0; i < 5; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr6(struct struct_arr6 s) {
+  int result = 0, i;
+  for (i = 0; i < 6; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr7(struct struct_arr7 s) {
+  int result = 0, i;
+  for (i = 0; i < 7; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr8(struct struct_arr8 s) {
+  int result = 0, i;
+  for (i = 0; i < 8; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr9(struct struct_arr9 s) {
+  int result = 0, i;
+  for (i = 0; i < 9; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr10(struct struct_arr10 s) {
+  int result = 0, i;
+  for (i = 0; i < 10; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr11(struct struct_arr11 s) {
+  int result = 0, i;
+  for (i = 0; i < 11; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr15(struct struct_arr15 s) {
+  int result = 0, i;
+  for (i = 0; i < 15; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr16(struct struct_arr16 s) {
+  int result = 0, i;
+  for (i = 0; i < 16; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr17(struct struct_arr17 s) {
+  int result = 0, i;
+  for (i = 0; i < 17; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr27(struct struct_arr27 s) {
+  int result = 0, i;
+  for (i = 0; i < 27; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr31(struct struct_arr31 s) {
+  int result = 0, i;
+  for (i = 0; i < 31; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr32(struct struct_arr32 s) {
+  int result = 0, i;
+  for (i = 0; i < 32; i++)
+    result += s.v[i];
+  return result;
+}
+
+int64_t pass_arr33(struct struct_arr33 s) {
+  int result = 0, i;
+  for (i = 0; i < 33; i++)
+    result += s.v[i];
+  return result;
+}

tests/test/cg/obj/tcext4.c

@@ -0,0 +1,117 @@
+#include <stdint.h>
+
+int64_t pass1(int8_t arr[1]) {
+ return arr[0];
+}
+
+int64_t pass2(int8_t arr[2]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 2; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass3(int8_t arr[3]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 3; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass4(int8_t arr[4]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 4; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass5(int8_t arr[5]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 5; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass7(int8_t arr[7]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 7; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass8(int8_t arr[8]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 8; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass9(int8_t arr[9]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 9; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass15(int8_t arr[15]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 15; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass16(int8_t arr[16]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 16; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass17(int8_t arr[17]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 17; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass24(int8_t arr[24]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 24; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass31(int8_t arr[31]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 31; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass32(int8_t arr[32]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 32; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}
+
+int64_t pass33(int8_t arr[33]) {
+  int i; int64_t sum = 0;
+  for (i = 0; i < 33; i++) {
+    sum += arr[i];
+  }
+  return sum;
+}

tests/test/cg/tcalext3.pp

@@ -0,0 +1,617 @@
+{ 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 tcext3.o}
+function pass1(s : struct1) : int64_t; cdecl; external;
+function pass2(s : struct2) : int64_t; cdecl; external;
+function pass3(s : struct3) : int64_t; cdecl; external;
+function pass4(s : struct4) : int64_t; cdecl; external;
+function pass5(s : struct5) : int64_t; cdecl; external;
+function pass6(s : struct6) : int64_t; cdecl; external;
+function pass7(s : struct7) : int64_t; cdecl; external;
+function pass8(s : struct8) : int64_t; cdecl; external;
+function pass9(s : struct9) : int64_t; cdecl; external;
+function pass10(s : struct10) : int64_t; cdecl; external;
+function pass11(s : struct11) : int64_t; cdecl; external;
+function pass12(s : struct12) : int64_t; cdecl; external;
+function pass13(s : struct13) : int64_t; cdecl; external;
+function pass14(s : struct14) : int64_t; cdecl; external;
+function pass15(s : struct15) : int64_t; cdecl; external;
+function pass31(s : struct31) : int64_t; cdecl; external;
+
+function pass_arr1(s : struct_arr1) : int64_t; cdecl; external;
+function pass_arr2(s : struct_arr2) : int64_t; cdecl; external;
+function pass_arr3(s : struct_arr3) : int64_t; cdecl; external;
+function pass_arr4(s : struct_arr4) : int64_t; cdecl; external;
+function pass_arr5(s : struct_arr5) : int64_t; cdecl; external;
+function pass_arr6(s : struct_arr6) : int64_t; cdecl; external;
+function pass_arr7(s : struct_arr7) : int64_t; cdecl; external;
+function pass_arr8(s : struct_arr8) : int64_t; cdecl; external;
+function pass_arr9(s : struct_arr9) : int64_t; cdecl; external;
+function pass_arr10(s : struct_arr10) : int64_t; cdecl; external;
+function pass_arr11(s : struct_arr11) : int64_t; cdecl; external;
+function pass_arr15(s : struct_arr15) : int64_t; cdecl; external;
+function pass_arr16(s : struct_arr16) : int64_t; cdecl; external;
+function pass_arr17(s : struct_arr17) : int64_t; cdecl; external;
+
+function pass_arr27(s : struct_arr27) : int64_t; cdecl; external;
+
+function pass_arr31(s : struct_arr31) : int64_t; cdecl; external;
+function pass_arr32(s : struct_arr32) : int64_t; cdecl; external;
+function pass_arr33(s : struct_arr33) : 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), check1(s1), 1);
+  verify(pass2(s2), check2(s2), 2);
+  verify(pass3(s3), check3(s3), 3);
+  verify(pass4(s4), check4(s4), 4);
+  verify(pass5(s5), check5(s5), 5);
+  verify(pass6(s6), check6(s6), 6);
+  verify(pass7(s7), check7(s7), 7);
+  verify(pass8(s8), check8(s8), 8);
+  verify(pass9(s9), check9(s9), 9);
+  verify(pass10(s10), check10(s10), 10);
+  verify(pass11(s11), check11(s11), 11);
+  verify(pass12(s12), check12(s12), 12);
+  verify(pass13(s13), check13(s13), 13);
+  verify(pass14(s14), check14(s14), 14);
+  verify(pass15(s15), check15(s15), 15);
+  verify(pass31(s31), check31(s31), 31);
+
+  verify(pass_arr1(sa1), check_arr1(sa1), 101);
+  verify(pass_arr2(sa2), check_arr2(sa2), 102);
+  verify(pass_arr3(sa3), check_arr3(sa3), 103);
+  verify(pass_arr4(sa4), check_arr4(sa4), 104);
+  verify(pass_arr5(sa5), check_arr5(sa5), 105);
+  verify(pass_arr6(sa6), check_arr6(sa6), 106);
+  verify(pass_arr7(sa7), check_arr7(sa7), 107);
+  verify(pass_arr8(sa8), check_arr8(sa8), 108);
+  verify(pass_arr9(sa9), check_arr9(sa9), 109);
+  verify(pass_arr10(sa10), check_arr10(sa10), 110);
+  verify(pass_arr11(sa11), check_arr11(sa11), 111);
+  verify(pass_arr15(sa15), check_arr15(sa15), 115);
+  verify(pass_arr16(sa16), check_arr16(sa16), 116);
+  verify(pass_arr17(sa17), check_arr17(sa17), 117);
+  verify(pass_arr27(sa27), check_arr27(sa27), 127);
+
+  verify(pass_arr31(sa31), check_arr31(sa31), 131);
+  verify(pass_arr32(sa32), check_arr32(sa32), 132);
+  verify(pass_arr33(sa33), check_arr33(sa33), 133);
+
+  if (not success) then
+    halt(1);
+end.

tests/test/cg/tcalext4.pp

@@ -0,0 +1,133 @@
+{ Tests passing of byte arrays by value of different sizes to C methods }
+program passvaluestest;
+{$MODE DELPHI}
+type
+  int8_t = shortint;
+  pint8_t = ^int8_t;
+
+var
+  success : boolean;
+
+{$packrecords c}
+
+type
+  arr1 = array[1..1] of int8_t;
+  arr2 = array[1..2] of int8_t;  
+  arr3 = array[1..3] of int8_t;  
+  arr4 = array[1..4] of int8_t;  
+  arr5 = array[1..5] of int8_t;  
+  arr7 = array[1..7] of int8_t;  
+  arr8 = array[1..8] of int8_t;  
+  arr9 = array[1..9] of int8_t;  
+  arr15 = array[1..15] of int8_t;  
+  arr16 = array[1..16] of int8_t;  
+  arr17 = array[1..17] of int8_t;  
+  arr24 = array[1..24] of int8_t;  
+  arr31 = array[1..31] of int8_t;  
+  arr32 = array[1..32] of int8_t;  
+  arr33 = array[1..33] of int8_t;  
+
+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; 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 check(const s : array of int8_t) : int64;
+var
+ i : Integer;
+begin
+  result := 0;
+  for i := low(s) to high(s) do 
+    inc(result, s[i]);
+end;
+
+{$L tcext4.o}
+function pass1(s : arr1) : int64; cdecl; external;
+function pass2(s : arr2) : int64; cdecl; external;
+function pass3(s : arr3) : int64; cdecl; external;
+function pass4(s : arr4) : int64; cdecl; external;
+function pass5(s : arr5) : int64; cdecl; external;
+function pass7(s : arr7) : int64; cdecl; external;
+function pass8(s : arr8) : int64; cdecl; external;
+function pass9(s : arr9) : int64; cdecl; external;
+function pass15(s : arr15) : int64; cdecl; external;
+function pass16(s : arr16) : int64; cdecl; external;
+function pass17(s : arr17) : int64; cdecl; external;
+function pass24(s : arr24) : int64; cdecl; external;
+function pass31(s : arr31) : int64; cdecl; external;
+function pass32(s : arr32) : int64; cdecl; external;
+function pass33(s : arr33) : int64; cdecl; external;
+
+var
+  s1 : arr1;
+  s2 : arr2;
+  s3 : arr3;
+  s4 : arr4;
+  s5 : arr5;
+  s7 : arr7;
+  s8 : arr8;
+  s9 : arr9;
+  s15 : arr15;
+  s16 : arr16;
+  s17 : arr17;
+  s24 : arr24;
+  s31 : arr31;
+  s32 : arr32;
+  s33 : arr33;
+
+begin
+  randseed := 20;
+  success := true;
+
+  fill(s1, sizeof(s1));
+  fill(s2, sizeof(s2));
+  fill(s3, sizeof(s3));
+  fill(s4, sizeof(s4));
+  fill(s5, sizeof(s5));
+  fill(s7, sizeof(s7));
+  fill(s8, sizeof(s8));
+  fill(s9, sizeof(s9));
+  fill(s15, sizeof(s15));
+  fill(s16, sizeof(s16));
+  fill(s17, sizeof(s17));
+  fill(s24, sizeof(s24));
+  fill(s31, sizeof(s31));
+  fill(s32, sizeof(s32));
+  fill(s33, sizeof(s33));
+
+  verify(pass1(s1), check(s1), 1);
+  verify(pass2(s2), check(s2), 2);
+  verify(pass3(s3), check(s3), 3);
+  verify(pass4(s4), check(s4), 4);
+  verify(pass5(s5), check(s5), 5);
+  verify(pass7(s7), check(s7), 7);
+  verify(pass8(s8), check(s8), 8);
+  verify(pass9(s9), check(s9), 9);
+  verify(pass15(s15), check(s15), 15);
+  verify(pass16(s16), check(s16), 16);
+  verify(pass17(s17), check(s17), 17);
+  verify(pass24(s24), check(s24), 24);
+  verify(pass31(s31), check(s31), 31);
+  verify(pass32(s32), check(s32), 32);
+  verify(pass33(s33), check(s33), 33);
+
+  if (not success) then
+    halt(1);
+end.