Hi,
W dniu 5.07.2023 o 11:11, David Brown pisze:
On 05/07/2023 10:05, Rafał Pietrak via Gcc wrote:
[-----------]
type) would then be smaller. At least, this is my understanding
of how it could work.
Note that this only applies to pointers declared to be of the address
space specific type. If you have "__smalldata int x;" using a
hypothetical new address space, then "&x" is of type "__smalldata int *"
and you need to specify the address space specific pointer type to get
the size advantages. (Since the __smalldata address space is a subset
of the generic space, conversions between pointer types are required to
work correctly.)
I see.
[--------]
thing like "#pragma" at the top of a file would do a better job),
better something then nothing. Then again, should you happen to fall
onto an actual documentation of syntax to use this feature with, I'd
appreciate you sharing it :)
I am not sure if you are clear about this, but the address space
definition macros here are for use in the source code for the compiler,
not in user code. There is (AFAIK) no way for user code to create
address spaces - you need to check out the source code for GCC, modify
it to support your new address space, and build your own compiler. This
is perfectly possible (it's all free and open source, after all), but it
is not a minor undertaking - especially if you don't like C++ !
Hmmm.
Wouldn't it be easier and more natural to make the "named spaces" a
synonym to specific linker sections (like section names, or section name
prefix when instead of ".data.array.*" one gets ".mynamespace.array.*")?
[------]
I realise that learning at least some C++ is a significant step beyond
learning C - but /using/ C++ classes or templates is no harder than C
coding. And it is far easier, faster and less disruptive to make a C++
header library implementing such features than adding new named address
spaces into the compiler itself.
The one key feature that is missing is that named address spaces can
affect the allocation details of data, which cannot be done with C++
classes. You could make a "small_data" class template, but variables
would still need to be marked __attribute__((section(".smalldata")))
when used. I think this could be handled very neatly with one single
additional feature in GCC - allow arbitrary GCC variable attributes to
be specified for types, which would then be applied to any variables
declared for that type.
OK. I see your point.
But let's have look at it. You say, that "names spaces affect allocation
details, which cannot be done with C++". Pls consider:
1. for small embedded devices C++ is not a particularly "seller". We
even turn to assembler occasionally.
2. affecting allocation details is usually the hole point of engineering
skills when dealing with small embedded devices - the hole point is to
have tools to do that.
So your current objections to named spaces ... are in fact in favor of
them. Isn't it so?
-R
