Hi Bart or anyone else who might know.

It looks to me like when a struct is passed by value,
that it manages to get clobbered anyway.

C:\devel\pdos\pdas>pdas --oformat coff --64 -o ../pdpclib/x64supb.obj ../pdpclib/x64supb.asm
OVERLAP0 and
yyy A:
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
yyy B:
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0
overlap0 is:
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
instruction types 0 is:
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0

OVERLAP0 and
yyy A:
1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
yyy B:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
overlap0 is:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
instruction types 0 is:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Can you confirm that is the case and suggest any workaround?

Relevant code here:

https://sourceforge.net/p/pdos/gitcode/ci/master/tree/pdas/src

https://sourceforge.net/p/pdos/gitcode/ci/master/tree/cc64/cc64.c

Thanks. Paul.

C:\devel\pdos\pdas>git diff .
diff --git a/pdas/src/i386_as.c b/pdas/src/i386_as.c
index ae7a26c2..92cf1845 100644
--- a/pdas/src/i386_as.c
+++ b/pdas/src/i386_as.c
@@ -518,7 +518,22 @@ static struct operand_type operand_type_or (struct operand_type a, struct operan
static struct operand_type operand_type_and (struct operand_type a, struct operand_type b)
{
size_t i;
- +
+ printf("yyy A: \n");
+ {
+ for (i = 0; i < sizeof (a)/sizeof (unsigned int); i++) {
+ printf ("%d ", ((unsigned int *)&a)[i]);
+ }
+ printf ("\n");
+ }
+ printf("yyy B: \n");
+ {
+ for (i = 0; i < sizeof (b)/sizeof (unsigned int); i++) {
+ printf ("%d ", ((unsigned int *)&b)[i]);
+ }
+ printf ("\n");
+ }
+ for (i = 0; i < sizeof (a); i++) {
((unsigned char *)&a)[i] &= ((unsigned char *)&b)[i];
}
@@ -2506,8 +2521,32 @@ static int match_template (char mnemonic_suffix)
if (instruction.operands == 0) break;

matching_error = x86_error_operand_type_mismatch;
- +
+ /* Skip the first to prove that operand_type_and destroys instruction.types[0]. */
+ if (found_reverse_match == 0) {
+ found_reverse_match = 1;
+ continue;
+ }
+ printf ("OVERLAP0 and\n");
operand_type_overlap0 = operand_type_and (instruction.types[0], template->operand_types[0]);
+ printf("overlap0 is: \n");
+ {
+ size_t i;
+ for (i = 0; i < sizeof (operand_type_overlap0)/sizeof (unsigned int); i++) {
+ printf ("%d ", ((unsigned int *)&operand_type_overlap0)[i]);
+ }
+ printf ("\n");
+ }
+ printf("instruction types 0 is: \n");
+ {
+ size_t i;
+ unsigned int *p = (unsigned int *)&instruction.types[0];
+ for (i = 0; i < sizeof (operand_type_overlap0)/sizeof (unsigned int); i++) {
+ printf ("%d ", p[i]);
+ }
+ printf ("\n\n");
+ }
+ continue; /* To reduce where instruction.types[0] might change. */

switch (template->operands) {

diff --git a/pdas/src/i386_opc.h b/pdas/src/i386_opc.h
index 85b1e0f6..936fac65 100644
--- a/pdas/src/i386_opc.h
+++ b/pdas/src/i386_opc.h
@@ -10,7 +10,7 @@
*****************************************************************************/
#define MAX_OPERANDS 3

-#define GENERATOR_MACRO(a) unsigned int a : 1;
+#define GENERATOR_MACRO(a) unsigned int a;

#define GENERATOR_CPU_FLAGS_LIST \
GENERATOR_MACRO(cpu_186) \

C:\devel\pdos\pdas>

On 04/09/2023 22:44, Paul Edwards wrote:
> Hi Bart or anyone else who might know.
>
> It looks to me like when a struct is passed by value,
> that it manages to get clobbered anyway.

This is a bad bug in the cc64 (bcc) project. One of many reasons why I
withdrew the project and made it private only.

In this 2017 compiler, value-struct passing support was poor, but also
it wasn't that common then. Then libraries like Raylib started using it
extensively.

One problem is that on typical ABIs, structs are not really passed by
value, but by reference. So to emulate pass-by-value, you need to make a
copy and pass a reference to that copy.

In the test program below, fred() can modify the value of the caller's
struct.

---------------------------------------
#include <stdio.h>

typedef struct {int a[3];} S;

void fred(S x) {
x.a[1]=777;
}

int main(void) {
S x = {{10,20,30}};

fred(x);
printf("%d %d %d\n", x.a[0], x.a[1], x.a[2]);
} ---------------------------------------

There isn't really a workaround; the compiler needs to be fixed. If you
need this now in my example, you might change the fred(x) call to:

S temp;
fred(temp = x);

or maybe:

S temp = x;
fred(temp);

On Tuesday, September 5, 2023 at 6:22:47 AM UTC+8, Bart wrote:

> In this 2017 compiler, value-struct passing support was poor, but also
> it wasn't that common then. Then libraries like Raylib started using it
> extensively.

It is interesting that this C90 feature was apparently only
used in anger (such that it caused an issue here) post-2017.

> One problem is that on typical ABIs, structs are not really passed by
> value, but by reference.

I see.

> There isn't really a workaround; the compiler needs to be fixed. If you
> need this now in my example, you might change the fred(x) call to:

I don't necessarily "need" things "now", but yes, I would like to
see if I can work around issues now.

> S temp;
> fred(temp = x);

Thanks. I went with this and it seems to be working.

C:\devel\pdos\pdas>git diff .
diff --git a/pdas/src/i386_as.c b/pdas/src/i386_as.c
index ae7a26c2..ddb87d53 100644
--- a/pdas/src/i386_as.c
+++ b/pdas/src/i386_as.c
@@ -2470,6 +2470,10 @@ static int match_template (char mnemonic_suffix)

for (template = current_templates->start; template < current_templates->end; template++) {
struct operand_type operand_type_overlap0, operand_type_overlap1;
+#ifdef __CC64__
+ struct operand_type temp;
+ #define operand_type_and(a, b) (operand_type_and)(temp = (a), (b))
+#endif
unsigned int size_match;

if (instruction.operands != template->operands) {

C:\devel\pdos\pdas>

BFN. Paul.

On 04/09/2023 23:45, Paul Edwards wrote:
> On Tuesday, September 5, 2023 at 6:22:47 AM UTC+8, Bart wrote:
>
>> In this 2017 compiler, value-struct passing support was poor, but also
>> it wasn't that common then. Then libraries like Raylib started using it
>> extensively.
>
> It is interesting that this C90 feature was apparently only
> used in anger (such that it caused an issue here) post-2017.

Actually I was thinking more about APIs. I'd used C APIs, mainly
Windows-related, since the mid-80s. Passing and returning structs by
value was rarely encountered, until I used Raylib.

But even Raylib didn't modify the passed structs that I recall.

(Interestingly, my own languages had had actual pass-by-value structs
and arrays for about 25 years, until I switched to Win ABI, but I never
used the feature.)