Re: Self-referential union?

[Basile Starynkevitch]

On Sun, 2025-02-02 at 16:45 +, Joe Finney wrote:
> Is it straightforward to make a union that references itself?
> 
>   union u {
>   int x;
>   union u *p;
>   }
> 
> With structs, I can use gcc_jit_context_new_opaque_struct, but there
> doesn't seem to be an equivalent for unions.


On most reasonable computers, every data pointer has the same size and
representation (so same size, same alignment, internally represented as some
"word" eg 64 bits).

So you could at least make the libgccjit calls to build the equivalent of 

union u {
   int x;
   void* p;
};

and then use libgccjit casts to transform the p to a union u* pointer.

Assuming your libgccjit context has some optimization enabled, the generated
code should be the same.

BTW if you want to generate quickly unoptimal code you may consider (instead of
libgccjit) using GNU lightning on https://www.gnu.org/software/lightning/ or
asmjit on https://asmjit.com/

In some cases, just generating C or C++ temporary code compiled to a plugin
could be simpler. See https://arxiv.org/abs/1109.0779 or the code on
https://github.com/bstarynk/bismon or on 
https://github.com/bstarynk/misc-basile/blob/master/manydl.c

Regards from near Paris in France

PS. My open source project is an inference engine on
https://github.com/RefPerSys/RefPerSys/

-- 
Basile STARYNKEVITCH   
8 rue de la Faïencerie
92340 Bourg-la-Reine,  France
http://starynkevitch.net/Basile & https://github.com/bstarynk 

Re: Self-referential union?

[Joe Finney]

Thanks for the response.

> On most reasonable computers, every data pointer has the same size and
> representation (so same size, same alignment, internally represented as some
> "word" eg 64 bits).
>
> So you could at least make the libgccjit calls to build the equivalent of 
>
> union u {
>int x;
>void* p;
> };
>
> and then use libgccjit casts to transform the p to a union u* pointer.
>
> Assuming your libgccjit context has some optimization enabled, the generated
> code should be the same.

I was either thinking of doing this, or else wrapping the union in a
struct, as in

struct s {
union {
int x;
struct s* p;
} u;
};

I think in both cases the generated code should optimize to the same? I
suspect that it would be a pretty substantial change to introduce a
gcc_jit_union type and gcc_jit_context_new_opaque_union, to match
structs, but not having those makes this feature significantly more
complicated to implement.

Self-referential union?

[Joe Finney]

Is it straightforward to make a union that references itself?

union u {
int x;
union u *p;
}

With structs, I can use gcc_jit_context_new_opaque_struct, but there
doesn't seem to be an equivalent for unions.