El 11/04/2010 6:14, Jesus Sanchez escribis:
quoted text
>    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