Re: relearning C: why does an in-place change to a char* segfault?

On 02/08/2024 01:37, Kaz Kylheku wrote:

On 2024-08-01, Bart <bc@freeuk.com> wrote:

On 01/08/2024 20:39, Kaz Kylheku wrote:

On 2024-08-01, Mark Summerfield <mark@qtrac.eu> wrote:

This program segfaults at the commented line:
>
#include <ctype.h>
#include <stdio.h>
>
void uppercase_ascii(char *s) {
      while (*s) {
          *s = toupper(*s); // SEGFAULT
          s++;
      }
}
>
int main() {
      char* text = "this is a test";

>
The "this is a test" object is a literal. It is part of the program's image.

>
So is the text here:
>
    char text[]="this is a test";
>
But this can be changed without making the program self-modifying.

 The array which is initialized by the literal is what can be
changed.
 In this situation, the literal is just initializer syntax,
not required to be an object with an address.

I don't spot the 'int main() {' part of your example; my version of it was meant to be static. (My A, B examples explicitly used 'static'.)

I guess it depends on what is classed as the program's 'image'.
>
I'd say the image in the state it is in just after loading or just
before execution starts (since certain fixups are needed). But some
sections will be writable during execution, some not.

 Programs can self-modify in ways designed into the run time.
The toaster has certain internal receptacles that can take
certain forks, according to some rules, which do not affect
the user operating the toaster according to the manual.
 

The dangers are small, but there must be reasons why a dedication
section is normally used. gcc on Windows creates up to 19 sections, so
it would odd for literal strings to share with code.

 One reason is that PC-relative addressing can be used by code to
find its literals. Since that usually has a limited range, it helps
to keep the literals with the code. Combining sections also reduces
size. The addressing is also relocatable, which is useful in shared
libs.

You must be talking about ARM then, with its limited address displacement (I think 12 bits or +/- 2KB).
On x64, PC-relative uses a 32-bit offset so the range is +/- 2GB; enough to have string literals located in their own read-only section of memory.
I'm sure you can do that on ARM too, I can think of several ways (and there are loads more registers to play with keep as bases to tables of such data). But I don't know what real code does.