Simple allocation of two buffer on AMD64

[jimenezrick]

- Code compiled by GCC:

int main(void)
{
char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);

return 0;
}

- Running it on AMD64 gives me:

0x7fff929c9410 0x7fff929c9400

- What is the reason for 16 bytes of distance between two address and
not just 8 bytes?

[Eric Sosman]

ji*********@gma il.com wrote:

- Code compiled by GCC:

int main(void)
{
char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);

return 0;
}

- Running it on AMD64 gives me:

0x7fff929c9410 0x7fff929c9400

- What is the reason for 16 bytes of distance between two address and
not just 8 bytes?

Ask the gcc implementors. It was they who decided how
the compiler should allocate space, not the C language itself.
C does not require a sixteen-byte separation, but does not
forbid it.

--
Eric Sosman
es*****@ieee-dot-org.invalid

[santosh]

ji*********@gma il.com wrote:

- Code compiled by GCC:

int main(void)
{
char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);

Cast 'a' and 'b' to void *.

>
return 0;
}

- Running it on AMD64 gives me:

0x7fff929c9410 0x7fff929c9400

- What is the reason for 16 bytes of distance between two address and
not just 8 bytes?

It's an implementation detail that Standard C says nothing about. It may
be due to alignment reasons.

[jimenezrick]

It's an implementation detail that Standard C says nothing about. It may

be due to alignment reasons.

I know. Just curiosity about the election of 16 bytes over 8 (what I
expected).

Thanks anyway.

[Justin Spahr-Summers]

On Nov 1, 7:54 am, santosh <santosh....@gm ail.comwrote:

jimenezr...@gma il.com wrote:

char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);

Cast 'a' and 'b' to void *.

Correct me if I'm wrong, but isn't this technically a case where it
shouldn't matter, seeing as char * and void * have the exact same
representation?

[jimenezrick]

Cast 'a' and 'b' to void *.

Same result.

Correct me if I'm wrong, but isn't this technically a case where it
shouldn't matter, seeing as char * and void * have the exact same
representation?

Yes, in this case is similar.

[Richard Tobin]

In article <11************ **********@o3g2 000hsb.googlegr oups.com>,
Justin Spahr-Summers <Ju************ *****@gmail.com wrote:

char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);

>Cast 'a' and 'b' to void *.

>Correct me if I'm wrong, but isn't this technically a case where it
shouldn't matter, seeing as char * and void * have the exact same
representation ?

We discussed this a few weeks ago. The idea seems to be that although
they have the same representation, they aren't necessarily passed to
variadic functions in the same way.

-- Richard

--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[CBFalconer]

ji*********@gma il.com wrote:

>
- Code compiled by GCC:

int main(void) {
char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);
return 0;
}

- Running it on AMD64 gives me:

0x7fff929c9410 0x7fff929c9400

- What is the reason for 16 bytes of distance between two address
and not just 8 bytes?

Many systems access memory in 128 bit chunks. Aligning objects to
this value prevents having to do two memory accesses, when one
suffices. Check the gcc docs for means of avoiding this if
desired.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home .att.net>

--
Posted via a free Usenet account from http://www.teranews.com

[Martin Ambuhl]

ji*********@gma il.com wrote:

- Code compiled by GCC:

int main(void)
{
char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);

return 0;
}

- Running it on AMD64 gives me:

0x7fff929c9410 0x7fff929c9400

- What is the reason for 16 bytes of distance between two address and
not just 8 bytes?

That is, of course, an issue between your hardware, your OS, and the
version of gcc you are using. There is no reason, as far as C is
concerned, for the addresses of two distinct objects to have any
particular relationship. But your post is extremely amusing. The fact
that you think it somehow appropriate for the difference to be eight
when sizeof a and sizeof b are each four is hilarious.

You really should include <stdio.hwhen using the variadic function printf.
Even with the special relationship between the form of (void *) and
(char *), you should cast pointers to (void *) when using the "%p"
specifier, since that is what it signals.

[jacob navia]

ji*********@gma il.com wrote:

- Code compiled by GCC:

int main(void)
{
char a[] = "123";
char b[] = "abc";

printf("%p %p\n", a, b);

return 0;
}

- Running it on AMD64 gives me:

0x7fff929c9410 0x7fff929c9400

- What is the reason for 16 bytes of distance between two address and
not just 8 bytes?

The stack MUST be aligned to an 8 byte boundary in
64 bits AMD/Intel. If that fails, each access provokes
a misaligned read, what makes performance take a
big hit.

Access to XMM registers in most cases MUST be aligned to a
16 byte boundary. If not, you can't load the 16 byte
XMM registers quickly.

Some compilers decide that performance is better than
wasting memory in the alignment, and align all variables
in the stack to a 16 byte boundary even when it is not
needed, as in your example.

Other compilers will say that performance by loading the XMM
registers is lost when the cache hits go down because the
program uses more memory and will NOT align to a 16 byte
boundary but only to a 8 byte boundary what is bad enough.

--
jacob navia
jacob at jacob point remcomp point fr
logiciels/informatique
http://www.cs.virginia.edu/~lcc-win32