Disadvantages of register storage class specifier

[aruna]

What is the disadvantage of using register
storage class specifier?

[Thomas Stegen]

aruna wrote:

What is the disadvantage of using register
storage class specifier?

Do your own homework, you will get better answers
in a book than you will get here.

--
Thomas.

[Lew Pitcher]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

aruna wrote:

What is the disadvantage of using register
storage class specifier?

In my opinion, the primary disadvantage is that you can't take the
address of a register variable.

Again, my opinion, but the 'register' storage class doesn't provide much
of an advantage when it is used: the compiler is permitted to ignore it
when selecting placement of variables, compiler optimization of
generated code may do a better job of optimizing placement than the
programmer can, and the language imposes restrictions on the use of
variables defined as register.

- --

Lew Pitcher, IT Consultant, Enterprise Application Architecture
Enterprise Technology Solutions, TD Bank Financial Group

(Opinions expressed here are my own, not my employer's)
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (MingW32)

iD8DBQFAj9fCagV FX4UWr64RApRVAK Cfs0M3p2yECKZbW Jd4Ypw0fj91vwCf Rlsu
IT1RBBQIMrWWkTL jc1yVdTY=
=L0q5
-----END PGP SIGNATURE-----

[Keith Thompson]

Lew Pitcher <Le*********@td .com> writes:

aruna wrote:

What is the disadvantage of using register
storage class specifier?
In my opinion, the primary disadvantage is that you can't take the
address of a register variable.

One could argue that that's an advantage. The "register" specifier is
a way of asserting to the compiler that a given variable won't have
its address taken. Theoretically a compiler could use that
information for optimization, even if it doesn't use it for its
original intent (storing the variable in a CPU register).

If my goal were to give the compiler as much information as possible,
I might even use a "register" specifier on *every* variable whose
address isn't taken. But the result wouldn't be pretty, and it
probably wouldn't do much good; any decent modern optimizing compiler
should be able to figure this out for itself.
Again, my opinion, but the 'register' storage class doesn't provide much
of an advantage when it is used: the compiler is permitted to ignore it
when selecting placement of variables, compiler optimization of
generated code may do a better job of optimizing placement than the
programmer can, and the language imposes restrictions on the use of
variables defined as register.

That's certainly the common wisdom, and I suspect compiler
implementers take that into account when deciding how much attention
to pay to "register" specifiers (i.e., not much). I've even read that
"register" can hurt optimization by interfering with the compiler's
own analysis, but I don't know if that's actually true.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
Schroedinger does Shakespeare: "To be *and* not to be"

[Christopher Benson-Manica]

Keith Thompson <ks***@mib.or g> spoke thus:

One could argue that that's an advantage. The "register" specifier is
a way of asserting to the compiler that a given variable won't have
its address taken. Theoretically a compiler could use that
information for optimization, even if it doesn't use it for its
original intent (storing the variable in a CPU register).
Setting aside theory, do any real implementations optimize based on
the fact that a given variable's address is never taken, aside from
placing that variable in a register or not?
to pay to "register" specifiers (i.e., not much). I've even read that
"register" can hurt optimization by interfering with the compiler's
own analysis, but I don't know if that's actually true.

I imagine that "register" can only hurt optimization as much as the
compiler lets it. It's a hint that I imagine is nowadays routinely
ignored by compilers.

--
Christopher Benson-Manica | I *should* know what I'm talking about - if I
ataru(at)cybers pace.org | don't, I need to know. Flames welcome.

[Christian Bau]

In article <a2************ **************@ posting.google. com>,
ar********@yaho o.co.in (aruna) wrote:

What is the disadvantage of using register
storage class specifier?

It requires typing seven characters, and it disallows usage of the
address operator. In some cases, it causes undefined behaviour.

Now ask for the advantages...

[Christian Bau]

In article <c6**********@c hessie.cirr.com >,
Christopher Benson-Manica <at***@nospam.c yberspace.org> wrote:

Keith Thompson <ks***@mib.or g> spoke thus:

One could argue that that's an advantage. The "register" specifier is
a way of asserting to the compiler that a given variable won't have
its address taken. Theoretically a compiler could use that
information for optimization, even if it doesn't use it for its
original intent (storing the variable in a CPU register).

Setting aside theory, do any real implementations optimize based on
the fact that a given variable's address is never taken, aside from
placing that variable in a register or not?

First, real implementations are more clever; even if the address of a
variable is taken, it is often possible to determine the set of accesses
to the variable exactly (this would be in practise more important for
C++ compilers + trivial classes + inline functions, but many compilers
implement both C and C++).

Second, if you know exactly all accesses to a variable, then you also
know that there is no aliasing, and that will help a lot. For example:

struct { int x; int y; int z; } t;
int *p;

t.x = 1; *p = 2;
t.y = t.x + 1; *p = 3;
t.z = t.x + t.y + 1; *p = 4;

Even if t.x, t.y and t.z are not in registers, the compiler may be able
to find that t.x, t.y and t.z are set to 1, 2 and 4, and *p needs only
be set once.

[Eric Sosman]

Christian Bau wrote:

In article <a2************ **************@ posting.google. com>,
ar********@yaho o.co.in (aruna) wrote:

What is the disadvantage of using register
storage class specifier?

It requires typing seven characters, [...]

Christian is a *fast* typist ...

--
Er*********@sun .com

[Tim Prince]

"Christophe r Benson-Manica" <at***@nospam.c yberspace.org> wrote in message
news:c6******** **@chessie.cirr .com...

Keith Thompson <ks***@mib.or g> spoke thus:

One could argue that that's an advantage. The "register" specifier is
a way of asserting to the compiler that a given variable won't have
its address taken. Theoretically a compiler could use that
information for optimization, even if it doesn't use it for its
original intent (storing the variable in a CPU register).

Setting aside theory, do any real implementations optimize based on
the fact that a given variable's address is never taken, aside from
placing that variable in a register or not?

Yes, if gcc is a real implementation. No, if you don't count registerization
as an optimization. I have bug issues pending against a commercial compiler,
where taking an address inhibits optimization more than it should.

[Mark Henning]

Eric Sosman wrote:

Christian Bau wrote:

In article <a2************ **************@ posting.google. com>,
ar********@yaho o.co.in (aruna) wrote:

What is the disadvantage of using register
storage class specifier?

It requires typing seven characters, [...]

Christian is a *fast* typist ...

Indeed. Can't say much about readability though. Its like
programming while pissed ;)

rgistr cst unsigd sht x;