El 11/04/2010 6:14, Jesus Sanchez escribis:
This is not really OpenBSD related but since it's a UNIX-like OS and
here are really experienced people coding in C I thought this was a good
place to ask.
Coding some simple stuff in C I ended up having a harmless mistake (I
hope) a double-declared variable with different types (char and int for
the example) in wich I did assignements beyond the bounds of the type
size. Let's call it foo, declared in files compiled separatedly. Also
say that everything it's compiled with gcc -c option (exect the final
executable) without warnings of any kind:
file a.c contains "char foo" on the code.
and b.c contains "int foo" on the code.
on the b.c file I made an assignement bigger than de byte limit,
let's say 0x2211 for the example. Back to a.c later than the 0x2211
assignement I printed the variable and showed 0x11 (at that point i
realized the mistake). But I was just wondering where the h*ll went the
0x22 bits on the memory?? I mean, the code reserved 1 byte as foo was
declared as a char, and I assined there more than expected (0x2211 for
example).
I know the rigth thing is to declare the variable 'foo' on a header
file and include it in all my code but I was just curious, what happends
to the upper 0x22 ?? Was I accessing to a ilegal zone of memory?? the
code executed without any error :o and the compiler showed no warning.
Thanks for your time, and sorry for my english.
-J
OK, doing a deep search I found this (think that my
foo variable is the symbol the quote talks about):
------------------------------------------------------------------
.comm declares a common symbol named symbol. When linking, a common
symbol in one object file may be merged with a defined or common symbol
of the same name in another object file. If ld does not see a definition
for the symbol--just one or more common symbols--then it will allocate
length bytes of uninitialized memory. length must be an absolute
expression. If ld sees multiple common symbols with the same name, and
they do not all have the same size, it will allocate space using the
largest size.
When using ELF, the .comm directive takes an optional third argument.
This is the desired alignment of the symbol, specified as a byte
boundary (for example, an alignment of 16 means that the least
significant 4 bits of the address should be zero). The alignment must be
an absolute expression, and it must be a power of two. If ld allocates
uninitialized memory for the common symbol, it will use the alignment
when placing the symbol. If no alignment is specified, as will set the
alignment to the largest power of two less than or equal to the size of
the symbol, up to a maximum of 16.
seen on:
http://stackoverflow.com/questions/501105/gcc-generated-assembly-comm
---------------------------------------------------------------------
so regarding my question, ld will use the largest memory space found as
a .comm foo,
so no harm at all with this mistake :D
thanks for your time anyway.
-J
