Question about struct type* ownership

Hi Tom, 

in response to my "Python JIT API" series [1] you pointed
out that there are rules about type ownership [2] I was not
aware of: 

> The issue is that in gdb there is a hidden rule: an objfile-specific
> type may only refer to other types from that objfile or to arch->
specific
> types.  Arch-specific types may only refer to other arch-specific
types.

While working on addressing this concern, more questions poped up:

Let's say I'd like to create new function type "int(struct s)", where
type "int" is arch-owned and "struct s" is objfile-owned. Am I correct
thinking that resulting function type should be objfile-owned? 

Generally speaking, if composing new type out of other types, if at
least one of the types is objfile-owned then the new type must by
also objfile-owned (by that very objfile), right? 

Looking at lookup_function_type_with_arguments, it allocated new
function type is always "owned" by whoever "owns" the return type
(first param to lookup_function_type_with_arguments). So if I'm correct
about the above, I'd have to extend lookup_function_type_with_arguments
to pass down type allocator (like in create_array_type). Or is there
a better way?

Also, when experimenting with the example above, I realized that 
the arch-owner of "int" struct type* is a different struct gdbarch *
then gdbarch associated with objfile-owner of "struct s" type
(i mean, pointer values are different).
While I would think it is okay to compose new type from types owned by 
two distinct gdbarchs from lifecycle POV, it still puzzles me why
there are two different gdbarch instances (both are i386:x86-64)?

Thanks! 

Best, Jan



[1]:
https://inbox.sourceware.org/gdb-patches/[email protected]/
[2]:
https://inbox.sourceware.org/gdb-patches/[email protected]/