pointers arithmetics

[Ivan Gotovchits]

Please, help me with the pointers.

I've a base pointer, say it is a 0x06000000 and offsets from it to
registers (for example, #define REG1 0x04). I'm accessing to them in a
following way.

void *base = MEMBASE; /* 0x06000000 */
uint32_t val = 0;

val = ((uint32_t) *(base + REG1));
/* do something with val */
((uint32_t) *(base + REG1)) = val;

Is this code correct? I'm not sure because sizeof(void *) = 4, so (base + 4)
will be (base + 4 * (sizeof(void *))), that will point me to the incorrect
address. If it is true, then what will be the correct method?

Thanks in advance.

--
s/.../.gotovchits/g for email.

[Richard Heathfield]

Ivan Gotovchits said:

Please, help me with the pointers.

I've a base pointer, say it is a 0x06000000 and offsets from it to
registers (for example, #define REG1 0x04). I'm accessing to them in a
following way.

void *base = MEMBASE; /* 0x06000000 */
uint32_t val = 0;

val = ((uint32_t) *(base + REG1));
/* do something with val */
((uint32_t) *(base + REG1)) = val;

Is this code correct?

No, it's not. The code performs arithmetic on a void *, which is not legal
C. Furthermore, the result of a cast is not a modifiable lvalue, so it
cannot be the left operand of an assignment statement.

I'm not sure because sizeof(void *) = 4, so (base +
4) will be (base + 4 * (sizeof(void *))),

No, even if sizeof(void *) is 4, this is of no consequence to the
expression (base + 4). When you add N to P (where P is a pointer to some
object type), the result is a pointer value that points N objects past P,
where the size of the object is determined by computing the size of the
kind of object to which P points. Since one cannot take the size of such
an object when P is of type void *, the calculation is illegal.

that will point me to the
incorrect address. If it is true, then what will be the correct method?

Well, there isn't a "correct" method, but there are less incorrect methods!
That is, the C Standard doesn't make any guarantees about what will happen
when you do the following:

#define MEMBASE (void *)0x06000000UL

void *base = MEMBASE; /* 0x06000000 */
unsigned char *ucbase = base;
uint32_t val = 0;

val = *(uint32_t)(ucbase + REG1);
/* do something with val */
*(uint32_t)(base + REG1) = val;

but it does at least have a fighting chance of working as you expect on
*some* (but by no means all) implementations.

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Gordon Burditt]

>I've a base pointer, say it is a 0x06000000 and offsets from it to

>registers (for example, #define REG1 0x04). I'm accessing to them in a
following way.

void *base = MEMBASE; /* 0x06000000 */
uint32_t val = 0;

val = ((uint32_t) *(base + REG1));

Don't try to do math on void* pointers.

>/* do something with val */
((uint32_t) *(base + REG1)) = val;

Is this code correct? I'm not sure because sizeof(void *) = 4,

Could be true but it's not relevant to this situation.

>so (base + 4)
will be (base + 4 * (sizeof(void *))),

No, actually that's (base add 4 mul (sizeof(void *))), using
assembly-language operators instead of C operators. That's picking
nits, but it's an important distinction.

No, sizeof(void) is not defined, so (base + 4) might be anything.

>that will point me to the incorrect
address. If it is true, then what will be the correct method?

What units are you trying to use for REG1? Maybe your pointer
should be char *.

[Ivan Gotovchits]

Gordon Burditt wrote:

Don't try to do math on void* pointers.

Yes, really it even fails to compile ...

What units are you trying to use for REG1? Maybe your pointer
should be char *.

I have a 32 bit register at the address base + 0x04 (i.e if base 0x06000000,
then reg will be found at the address 0x06000004)

--
s/.../.gotovchits/g for email.

[Ivan Gotovchits]

Richard Heathfield wrote:

Ivan Gotovchits said:

>Please, help me with the pointers.

I've a base pointer, say it is a 0x06000000 and offsets from it to
registers (for example, #define REG1 0x04). I'm accessing to them in a
following way.

void *base = MEMBASE; /* 0x06000000 */
uint32_t val = 0;

val = ((uint32_t) *(base + REG1));
/* do something with val */
((uint32_t) *(base + REG1)) = val;

Is this code correct?

No, it's not. The code performs arithmetic on a void *, which is not legal
C. Furthermore, the result of a cast is not a modifiable lvalue, so it
cannot be the left operand of an assignment statement.

>I'm not sure because sizeof(void *) = 4, so (base +
4) will be (base + 4 * (sizeof(void *))),

No, even if sizeof(void *) is 4, this is of no consequence to the
expression (base + 4). When you add N to P (where P is a pointer to some
object type), the result is a pointer value that points N objects past P,
where the size of the object is determined by computing the size of the
kind of object to which P points. Since one cannot take the size of such
an object when P is of type void *, the calculation is illegal.

>that will point me to the
incorrect address. If it is true, then what will be the correct method?

Well, there isn't a "correct" method, but there are less incorrect
methods! That is, the C Standard doesn't make any guarantees about what
will happen when you do the following:

#define MEMBASE (void *)0x06000000UL

void *base = MEMBASE; /* 0x06000000 */
unsigned char *ucbase = base;
uint32_t val = 0;

val = *(uint32_t)(ucbase + REG1);
/* do something with val */
*(uint32_t)(base + REG1) = val;

but it does at least have a fighting chance of working as you expect on
*some* (but by no means all) implementations.

Thanks, I understand my errors.
So after all maybe it is better to use, something like this:

uint32_t *base = MEMBASE;
uint32_t *val = 0;

val = *(base + REG1/sizeof(uint32_t));

Will be this correct, if I know for sure that REG1 is divisable by 4?

--
s/.../.gotovchits/g for email.

[Richard Heathfield]

Ivan Gotovchits said:

<snip>

So after all maybe it is better to use, something like this:

uint32_t *base = MEMBASE;
uint32_t *val = 0;

val = *(base + REG1/sizeof(uint32_t));

That's better, but better still (if you have control over REG1) would be to
define it as 1 rather than 4, allowing you to do this:

val = base[REG1];

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Ivan Gotovchits]

Richard Heathfield wrote:

Ivan Gotovchits said:

<snip>

>So after all maybe it is better to use, something like this:

uint32_t *base = MEMBASE;
uint32_t *val = 0;

val = *(base + REG1/sizeof(uint32_t));

That's better, but better still (if you have control over REG1) would be
to define it as 1 rather than 4, allowing you to do this:

val = base[REG1];

Not really a full control. I have lots of them defined in the system header
file. So it is not a good idea to touch it.
--
s/.../.gotovchits/g for email.

[Tor Rustad]

Ivan Gotovchits wrote:

Please, help me with the pointers.

I've a base pointer, say it is a 0x06000000 and offsets from it to
registers (for example, #define REG1 0x04). I'm accessing to them in a
following way.

void *base = MEMBASE; /* 0x06000000 */
uint32_t val = 0;

val = ((uint32_t) *(base + REG1));
/* do something with val */
((uint32_t) *(base + REG1)) = val;

Is this code correct? I'm not sure because sizeof(void *) = 4, so (base + 4)
will be (base + 4 * (sizeof(void *))), that will point me to the incorrect
address. If it is true, then what will be the correct method?

As others have told you, void* arithmetic don't work.
I recommend that you start with writing two functions:

reg_set(REG_N, val);

val = reg_get(REG_N);
--
Tor <torust [at] online [dot] no>

[Ivan Gotovchits]

Ivan Gotovchits wrote:

uint32_t *base = MEMBASE;
uint32_t *val = 0;

val = *(base + REG1/sizeof(uint32_t));

And I have another idea

uint32_t *base = MEMBASE;
uint32_t *val = 0;

val = *(((char *)base) + REG);

and it can be made a macros:
#define get_reg(REG) *(((char *)base) + REG)

Is it right and can it be simplified in any way?

--
s/.../.gotovchits/g for email.

[Peter 'Shaggy' Haywood]

Groovy hepcat Richard Heathfield was jivin' in comp.lang.c on Mon, 24
Sep 2007 10:12 pm. It's a cool scene! Dig it.

#define MEMBASE (void *)0x06000000UL

void *base = MEMBASE; /* 0x06000000 */
unsigned char *ucbase = base;
uint32_t val = 0;

val = *(uint32_t)(ucbase + REG1);
/* do something with val */
*(uint32_t)(base + REG1) = val;

^^^^
No doubt you meant ucbase, not base. Otherwise it has no chance of
working on any conforming implementation. (I don't know what it might
do on Jacob's compiler, however. <g,d&r>)

--
Dig the sig!

----------- Peter 'Shaggy' Haywood ------------
Ain't I'm a dawg!!

[Richard Heathfield]

Peter 'Shaggy' Haywood said:

Groovy hepcat Richard Heathfield was jivin' in comp.lang.c on Mon, 24
Sep 2007 10:12 pm. It's a cool scene! Dig it.

>#define MEMBASE (void *)0x06000000UL

void *base = MEMBASE; /* 0x06000000 */
unsigned char *ucbase = base;
uint32_t val = 0;

val = *(uint32_t)(ucbase + REG1);
/* do something with val */
*(uint32_t)(base + REG1) = val;

^^^^
No doubt you meant ucbase, not base.

It doesn't seem to matter how carefully we check this stuff, does it?
There's *always* something.

Thank you, Peter. Better late than never. :-)

--
Richard Heathfield <http://www.cpax.org.uk>
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999