Q: volatile struct elements or entire struct?

[Mark A. Odell]

If I have a structure that may point to a volatile "region (e.g. device)"
or a context in memory what would be the best way to use the volatile
keyword?

E.g.

a) volatile on struct objects

struct Foo
{
unsigned char command;
unsigned char status;
unsigned long baseAddr;
unsigned long addrRange;
}

volatile struct Foo *pDevFoo = (some dev. address);
struct Foo hostFoo;
- or -
b) volatile on struct members

struct Foo
{
volatile unsigned char command;
volatile unsigned char status;
volatile unsigned long baseAddr;
volatile unsigned long addrRange;
}

struct Foo *pDevFoo = (some dev. address);
struct Foo hostFoo; /* live with extra accesses */
Does my use of volatile in a) even do what I intend? That is, make
accesses to the device volatile?

Thanks.

--
- Mark ->
--

[Chris Torek]

In article <news:Xn********************************@130.133.1 .4>
Mark A. Odell <od*******@hotmail.com> wrote:

[which of these should one use:]

a) volatile on struct objects

struct Foo {
unsigned char command;
unsigned char status;
unsigned long baseAddr;
unsigned long addrRange;
}

volatile struct Foo *pDevFoo = (some dev. address);
struct Foo hostFoo;
This is the version I prefer, for several reasons, the most valid :-)
being the one shown right here in your example: you can make a
non-volatile version of it.
b) volatile on struct members

struct Foo
{
volatile unsigned char command;
volatile unsigned char status;
volatile unsigned long baseAddr;
volatile unsigned long addrRange;
}

struct Foo *pDevFoo = (some dev. address);
struct Foo hostFoo; /* live with extra accesses */

Does my use of volatile in a) even do what I intend? That is, make
accesses to the device volatile?

Yes. Both methods work (provided, of course, that your implementation's
definition of "volatile" does what you need in the first place --
if not, neither method works anyway!).
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (40°39.22'N, 111°50.29'W) [phone]
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.

[Mark A. Odell]

Chris Torek <no****@torek.net> wrote in
news:ci*********@news4.newsguy.com:

In article <news:Xn********************************@130.133.1 .4>
Mark A. Odell <od*******@hotmail.com> wrote:

[which of these should one use:]

a) volatile on struct objects

struct Foo {
unsigned char command;
unsigned char status;
unsigned long baseAddr;
unsigned long addrRange;
}

volatile struct Foo *pDevFoo = (some dev. address);
struct Foo hostFoo;
This is the version I prefer, for several reasons, the most valid :-)
being the one shown right here in your example: you can make a
non-volatile version of it.

Excellent.

b) volatile on struct members

struct Foo
{
volatile unsigned char command;
volatile unsigned char status;
volatile unsigned long baseAddr;
volatile unsigned long addrRange;
}

struct Foo *pDevFoo = (some dev. address);
struct Foo hostFoo; /* live with extra accesses */

Does my use of volatile in a) even do what I intend? That is, make
accesses to the device volatile?

Yes. Both methods work (provided, of course, that your implementation's
definition of "volatile" does what you need in the first place --
if not, neither method works anyway!).

Oh it does, this has been heavily verified. Cross-compilers tend to this
as one my hope for.

Thanks Chirs.

--
- Mark ->
--

[Mark A. Odell]

"Mark A. Odell" <od*******@hotmail.com> wrote in
news:Xn********************************@130.133.1. 4:

Oh it does, this has been heavily verified. Cross-compilers tend to this
as one my hope for.

^^
might

--
- Mark ->
--