From 55a2007321c6de03f94be72b39f91deb3f8cddb7 Mon Sep 17 00:00:00 2001 From: Jonas Maebe Date: Fri, 7 Apr 2006 22:17:45 +0000 Subject: [PATCH] * 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 | 3 + compiler/powerpc/cpupara.pas | 16 +- tests/test/cg/obj/darwin/powerpc/tcext5.o | Bin 0 -> 8252 bytes tests/test/cg/obj/tcext5.c | 459 ++++++++++++++++ tests/test/cg/tcalext5.pp | 626 ++++++++++++++++++++++ 5 files changed, 1102 insertions(+), 2 deletions(-) create mode 100644 tests/test/cg/obj/darwin/powerpc/tcext5.o create mode 100644 tests/test/cg/obj/tcext5.c create mode 100644 tests/test/cg/tcalext5.pp diff --git a/.gitattributes b/.gitattributes index 30ca228894..c6106ff159 100644 --- a/.gitattributes +++ b/.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 diff --git a/compiler/powerpc/cpupara.pas b/compiler/powerpc/cpupara.pas index 55109d3c59..8df6ce909a 100644 --- a/compiler/powerpc/cpupara.pas +++ b/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; diff --git a/tests/test/cg/obj/darwin/powerpc/tcext5.o b/tests/test/cg/obj/darwin/powerpc/tcext5.o new file mode 100644 index 0000000000000000000000000000000000000000..82aed84d97b8abff1e66ed0392c6fa6fb57e87c1 GIT binary patch literal 8252 zcmcgxUuauZ82^&=Pr7zX+r=4c%(5+LWC4>k&N~cUHW9*BN5MYip(I_+G_KpB6MU#5GQ>Z9l06P&pdd12HvYbQ&Ta3~-fYf$bK&Ov z&bjBD@Avz@bIv{IX6feN-xErOd;{(lZ;2l`TYH!sdYr`SrFhtZmzFWP4uNj+$W` zde+kIFtDwx*me}*gMGpWcDIFGS`4@ZD(nXn{Len9&LQUW+d2M2&^09E-)dkxjMyf$ zaZ<9Ir{91_TO%Hb36EEd2g`Z18}Nv+KbCpywY%Y)1161)t2{puBM*Gzl`$Gc|D!TS z&N@zh)D2*cy0!U-`KXp5@5lTMG?fj@mZjWKHG4=JP~*1*{pHs zGT@oHn?Kj&x#H_bo9OFq0}X+x0jxDC@>Wt}T`Ql${29mkGKuwN?w;0{3;MNHTkon% zXz!yC)~PVosVL^-TdWuRq0Mz%6s&tOta~R{aoGnhkN5Bztgdkyw~CL#cg!W}Q}{c& zYFw=NduIcGE8xiQ9|db^tif7(uUg-gTKxuEdGDwCL+(9dc)uu`ea7q)EpH;9Ek=Cc zyHl#~#9pXbe6||!;XUHC;G^ylnH%=W%X^dibQDqMEm5zV`vVt`VkaBd=ep>Z;%95$i8@Pp@bp4s2+xD4 ztF8y|ziLa%-%ZDb#yVcKNQcdA9Svgfl0_QqW@|t!8;z-~MLHa2>(I^;x_P0UDaI|* z(9%Q=FI%LcwTT)ITcn}QYz;goa6TPrFs5<_TJm!I@md>I*HRzmSG?Cfjd#mEuD9*b zvtZ_WTe{lMXWoo%Ze-*;uOvo&b*8~e;rd=tuO--OoCRIo^s%WO?$dWPq?Hg9=fn3Hq-xJ4SeP1g{Ao;4J7 zaVSU)CoIy?XSN0%_t)gP<8_O;`^@HEKQHj@Ad7DYxtRgV&!p~%i>B?QMcOu-txXq~ z6EZGuSj63L2KV@a_veL+yOO(y#-97(kMpz!iZz zZUDb2@H%e$p1_?>;7tPCP69t7F}Do}Z0GXr0y~(`4vFW1cM06W<>v+Nf)-nsz#D%A z_6Y2r1(tn2FajJF<(vG#F^T^~KNkgFKaX?a~SipZWKva5*fD{!a(}qv176- zLs^-jw8T&vV<_!0lqMNU4Gg6YhEfYdO^=Fo_B8%#xvs;AuE!lZtm)(W{d%(f^e-W= BTrU6s literal 0 HcmV?d00001 diff --git a/tests/test/cg/obj/tcext5.c b/tests/test/cg/obj/tcext5.c new file mode 100644 index 0000000000..35dcb37304 --- /dev/null +++ b/tests/test/cg/obj/tcext5.c @@ -0,0 +1,459 @@ +#include + +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; +} diff --git a/tests/test/cg/tcalext5.pp b/tests/test/cg/tcalext5.pp new file mode 100644 index 0000000000..edaf8a3626 --- /dev/null +++ b/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.