"Francois Gouget" fgouget@free.fr wrote:
We find the same issues with an added twist: now that we can use literals we can write things like:
const char* str = "String literal";
However this is slightly different from:
static const char* str[] = "String literal";
The difference is that in the first case sizeof(str) returns 4 (on 32 bit machines<g>) while in the latter we get 15. Some of our code relies on this so care must be taken when converting the latter to the former.
My understanding of this is that in the first case you declare a const pointer and hope that a compiler is smart enough to place a pointed by it object into a read only section, while in the second case you explicitly say to a compiler to place the whole object into a read only section.
I prefer to not rely on a compiler's good will.
On April 24, 2004 10:30 am, Dmitry Timoshkov wrote:
I prefer to not rely on a compiler's good will.
To be honest, I don't much see the point of this patch myself. If you want to look at the constantness of strings, there was an effort back in Oct 2003 by Daniel Marmier to fix things up so that we can compile Wine with -Wwrite-strings: http://www.winehq.org/hypermail/wine-devel/2003/10/0269.html
I am not sure if this was completed (Daniel did submit a lot of patches to wine-patches back in Oct), but it certainly is a worthy goal. We should probably finish this off, and add the flag by default to CFLAGS.
Daniel, if you read this, do you remember the status? Some pointers on what remains to be done would be appreciated.
On Sat, 24 Apr 2004, Dimitrie O. Paun wrote:
On April 24, 2004 10:30 am, Dmitry Timoshkov wrote:
I prefer to not rely on a compiler's good will.
To be honest, I don't much see the point of this patch myself.
Maybe the text at the beginning made it look like this is just about 'const char*' vs 'const char []'. But what it's really about is adding const and static where appropriate.
* const Causes the strings to be put into a read-only section. Stuff from read-only sections can be simply discarded when memory is low instead of having to be written out to the wap file. That's because it can be read back from the executable.
* static Stops the compiler from generating code that copies strings to the stack each time we enter the function.
Doesn't that count for anything?
If you want to look at the constantness of strings, there was an effort back in Oct 2003 by Daniel Marmier to fix things up so that we can compile Wine with -Wwrite-strings: http://www.winehq.org/hypermail/wine-devel/2003/10/0269.html
That's certainly useful too but I see this as a pretty different issue. And you'll still get a ton of warnings if you add '-Wwrite-strings' to gcc's options.
On Sat, 24 Apr 2004, Dmitry Timoshkov wrote:
"Francois Gouget" fgouget@free.fr wrote:
We find the same issues with an added twist: now that we can use literals we can write things like:
const char* str = "String literal";
However this is slightly different from:
static const char* str[] = "String literal";
The difference is that in the first case sizeof(str) returns 4 (on 32 bit machines<g>) while in the latter we get 15. Some of our code relies on this so care must be taken when converting the latter to the former.
My understanding of this is that in the first case you declare a const pointer and hope that a compiler is smart enough to place a pointed by it object into a read only section, while in the second case you explicitly say to a compiler to place the whole object into a read only section.
In the first case you declare a const pointer and hope the compiler will place the string in a const section. In the second case you declare a const buffer and hope the compiler will put it in a read-only section.
If the compiler is too dumb to do the former I don't see that there's any garantee it will do the latter. Also I'd say that if the compiler is too dumb to handle one form or the other properly, then it's not worth even considering. Fortunately it's a moot point because gcc handles both cases just fine.
Francois Gouget fgouget@free.fr writes:
On Sat, 24 Apr 2004, Dmitry Timoshkov wrote:
"Francois Gouget" fgouget@free.fr wrote:
We find the same issues with an added twist: now that we can use literals we can write things like:
const char* str = "String literal";
However this is slightly different from:
static const char* str[] = "String literal";
The difference is that in the first case sizeof(str) returns 4 (on 32 bit machines<g>) while in the latter we get 15. Some of our code relies on this so care must be taken when converting the latter to the former.
My understanding of this is that in the first case you declare a const pointer and hope that a compiler is smart enough to place a pointed by it object into a read only section, while in the second case you explicitly say to a compiler to place the whole object into a read only section.
In the first case you declare a const pointer and hope the compiler will place the string in a const section. In the second case you declare a const buffer and hope the compiler will put it in a read-only section.
The first case is not a const pointer, it's a pointer to a const string, and it requires the compiler to allocate separate (writable) storage for the pointer, so you are wasting 4 bytes per string. You could use 'const char * const' to at least put the 4 bytes in read-only storage, but unless there's a real need for a separate pointer, using the buffer form is much preferable.
On Mon, 26 Apr 2004, Alexandre Julliard wrote: [...]
The first case is not a const pointer, it's a pointer to a const string, and it requires the compiler to allocate separate (writable) storage for the pointer, so you are wasting 4 bytes per string. You could use 'const char * const' to at least put the 4 bytes in read-only storage, but unless there's a real need for a separate pointer, using the buffer form is much preferable.
Makes sense. No problem, I'll resubmit.
-
Alexandre Julliard -
Dimitrie O. Paun -
Dmitry Timoshkov -
Francois Gouget