If your web browser formats this page incorrectly, try viewing the
page source. In netscape 4, click the view menu, then click page source.
When a program has a segmentation fault, that means that the operating
system stopped the program because the program attempted to read or write
memory which the program was not supposes to read or write. This is the same
as what microsuck windoze calls a general protection fault.
A segmentation fault could be caused by a bug. The most likely bug is a
pointer which is set to the wrong value, or set to a random value because
you forgot to set the initial value of the pointer.
A segmentation fault could be caused by attempting to write to read only
memory. When gcc compiles and links a program, gcc divides the program into
parts. Some parts are both readable and writable. Some parts are readable
but not writeable. If the program attempts to write to a read only part, a
segmentation fault occurs. So the segmentation fault occurs because gcc put
parts of the program which were supposed to be writeable into a read only
part. This is probably the fault of the program for failing to properly
declare whether each datum was constant or variable.
It is too bad that gcc does not automatically detect statements in the
source code which attempt to write to read only memory, or that segmentation
faults do not produce an error message saying which line of the source code
caused the segmentation fault.
gcc has some options which cause gcc to make more of the program writeable,
which may prevent segmentation faults. -fwritable-strings sometimes helps.
man ld says that --omagic causes ld to make all of the program writeable,
among other things; but I tried using gcc option "-Xlinker --omagic" and the
resulting executable binary would not run. I guess omagic format is not
compatible with linux.
I compiled larn 12.2.4 on fedora 2 linux. larn segfaulted frequently. The
problem was that larn sometimes writes to strings, but gcc assumes all
strings are constant, and so gcc put the strings in a read only segment, so
larn segfaults when larn attempts to write to the strings. I fixed the
problem by editing the makefile and adding -fwritable-strings to CFLAGS.
CFLAGS was used when compiling, but not when linking, so the option
-fwritable-strings was used when compiling but not when linking. I do not
know what would have happened if I had used -fwritable-strings when linking.
