Limit on maximum number of register variable in C program

[alakesh.haloi]

Hi All
Is there a limit on the number of register variables that can be
declared and initialized in a C program on a particular hardware
platform? If you define more number of register variables than the
processor has, how is it handled by the C compiler?

regards

[dandelion]

<al***********@ gmail.com> wrote in message
news:11******** *************@z 14g2000cwz.goog legroups.com...

Hi All
Is there a limit on the number of register variables that can be
declared and initialized in a C program on a particular hardware
platform?
No. However, the compiler is not obliged to honour any of them.
If you define more number of register variables than the
processor has, how is it handled by the C compiler?

By ignoring the "register" keyword for most/all of the variables you
declared that way.

Using the "register" keyword is seldomly very desirable. In most cases, an
optimizing compiler
will put variables in a register anyway (if it can, that is). Hence the
keyword 'volatile" which explicitly prevents this.

The only case where "register" is handly, is when you want to pass a hint to
the compiler about what to optimize.

[James McIninch]

<posted & mailed>

The register keyword is merely a hint to the compiler. it doesn't force a
variable into a register. So, there's no limit to what can be declared
register, or how many variables. The compiler will simply choose some and
ignore the rest.

al***********@g mail.com wrote:

Hi All
Is there a limit on the number of register variables that can be
declared and initialized in a C program on a particular hardware
platform? If you define more number of register variables than the
processor has, how is it handled by the C compiler?

regards

--
Remove '.nospam' from e-mail address to reply by e-mail

[Keith Thompson]

"dandelion" <da*******@mead ow.net> writes:

<al***********@ gmail.com> wrote in message
news:11******** *************@z 14g2000cwz.goog legroups.com...

Hi All
Is there a limit on the number of register variables that can be
declared and initialized in a C program on a particular hardware
platform?

No. However, the compiler is not obliged to honour any of them.

If you define more number of register variables than the
processor has, how is it handled by the C compiler?

By ignoring the "register" keyword for most/all of the variables you
declared that way.

It can't completely ignore it; it still has to forbid (or at least
issue a diagnostic for) any attempt to take the address of a
register-qualified variable.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Ben Pfaff]

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

"dandelion" <da*******@mead ow.net> writes:

By ignoring the "register" keyword for most/all of the variables you
declared that way.

It can't completely ignore it; it still has to forbid (or at least
issue a diagnostic for) any attempt to take the address of a
register-qualified variable.

A lousy implementation might issue a warning for taking the
address of *any* variable, I suppose.
--
"To get the best out of this book, I strongly recommend that you read it."
--Richard Heathfield

[Dave Vandervies]

In article <87************ @benpfaff.org>,
Ben Pfaff <bl*@cs.stanfor d.edu> wrote:

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

"dandelion" <da*******@mead ow.net> writes:

By ignoring the "register" keyword for most/all of the variables you
declared that way.

It can't completely ignore it; it still has to forbid (or at least
issue a diagnostic for) any attempt to take the address of a
register-qualified variable.

A lousy implementation might issue a warning for taking the
address of *any* variable, I suppose.

A rather more reasonable way to avoid doing the work of recognizing this
case is to issue a warning any time it sees the register keyword.
dave

--
Dave Vandervies dj******@csclub .uwaterloo.ca
I will really not become the pilot, policeman or professional soccer player of
my childhood dreams, for I had none. I always envisioned myself still playing
with lego all those eons later. --Pim van Riezen in the scary devil monastery

[Alan Balmer]

On Wed, 23 Feb 2005 22:45:52 +0000 (UTC), dj******@csclub .uwaterloo.ca
(Dave Vandervies) wrote:

In article <87************ @benpfaff.org>,
Ben Pfaff <bl*@cs.stanfor d.edu> wrote:

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

"dandelion" <da*******@mead ow.net> writes:
By ignoring the "register" keyword for most/all of the variables you
declared that way.

It can't completely ignore it; it still has to forbid (or at least
issue a diagnostic for) any attempt to take the address of a
register-qualified variable.

A lousy implementation might issue a warning for taking the
address of *any* variable, I suppose.

A rather more reasonable way to avoid doing the work of recognizing this
case is to issue a warning any time it sees the register keyword.

Yechh. I have to work with a (HP-UX) compiler which issues a warning
every time it sees "const", whether or not it's used properly.

--
Al Balmer
Balmer Consulting
re************* ***********@att .net

[Peter Nilsson]

> <al***********@ gmail.com> wrote in message

news:11******** *************@z 14g2000cwz.goog legroups.com...

Hi All
Is there a limit on the number of register variables that can be
declared and initialized in a C program on a particular hardware
platform?

The standard puts it best: "A declaration of an identifier for an
object with storage-class specifier register suggests that access
to the object be as fast as possible. The extent to which such
suggestions are effective is implementation-defined."

So, register is simply a hint to the compiler, although the compiler
is free to ignore the hind.

dandelion wrote: No. However, the compiler is not obliged to honour any of them.

If you define more number of register variables than the
processor has, how is it handled by the C compiler?
By ignoring the "register" keyword for most/all of the variables you
declared that way.

Using the "register" keyword is seldomly very desirable.

That's overstating it.
In most cases, an optimizing compiler will put variables in a register anyway (if it can, that is).
True.
Hence the keyword 'volatile" which
explicitly prevents this.

No. The volatile keyword is a type qualifier, not a storage specifier.
It serves a different purpose. They are not mutually exclusive.

#include <stdio.h>

int main()
{
register volatile int x = 42;
printf("%d\n", x);
return 0;
}
--
Peter

[Dave Vandervies]

In article <s8************ *************** *****@4ax.com>,
Alan Balmer <al******@spamc op.net> wrote:

On Wed, 23 Feb 2005 22:45:52 +0000 (UTC), dj******@csclub .uwaterloo.ca
(Dave Vandervies) wrote:

In article <87************ @benpfaff.org>,
Ben Pfaff <bl*@cs.stanfor d.edu> wrote:
[discussing appropriate diagnostics for an implementation that ignores
`register']

A lousy implementation might issue a warning for taking the
address of *any* variable, I suppose.
A rather more reasonable way to avoid doing the work of recognizing this
case is to issue a warning any time it sees the register keyword.

Yechh. I have to work with a (HP-UX) compiler which issues a warning
every time it sees "const", whether or not it's used properly.

This is much less unreasonable for register than it is for const, just
because of the way the two are used.

But even for const... would you prefer that the compiler warned every
time the code modified an object, because that object could have been
declared const and the compiler knew it ignored the const if there was
one and might therefore have missed a constraint violation?
dave

--
Dave Vandervies dj******@csclub .uwaterloo.ca Well, it's rather far from rocket science, mixing it up....

Actually, I hear it's a primary ingredient in the space shuttle's solid rocket
boosters. --Ingvar the Grey and Phillip Jones in the Scary Devil Monastery

[Richard Bos]

dj******@csclub .uwaterloo.ca (Dave Vandervies) wrote:

Alan Balmer <al******@spamc op.net> wrote:

Yechh. I have to work with a (HP-UX) compiler which issues a warning
every time it sees "const", whether or not it's used properly.

This is much less unreasonable for register than it is for const, just
because of the way the two are used.

But even for const... would you prefer that the compiler warned every
time the code modified an object, because that object could have been
declared const and the compiler knew it ignored the const if there was
one and might therefore have missed a constraint violation?

I'd rather that it warn every time I assigned away the const, or assign
to a known-const object. The compiler _knows_ which objects are const;
it also knows when I do something unsafe with one of them.

Richard