C programming on ARM

Use two pointers of the same type.

Or cast to the correct type (if you are sure and know what you're doing).

If he knew what he was doing, he wouldn't have posted that question. ;)

Caution. Most pointer casts are implementation defined. The exception is casting to and from void*, and from void* back to the original type.

Try proper casting.

Karthik Balaguru

In which case would an arbitrary pointer casting be a problem ?

The only situation I can think of is for instance some DSP with 24 bit addressable unit or some old 36 bit mainframe, in which for instance a char* would require the memory word and also information which quarter word is referenced.

With any byte addressable architecture, a pointer is just a pointer.

Paul

Roughly all of them. The real question is how violently the problem will show itself. Some of them can lie dormant for a decade before a platform change exposes them as total show-stoppers.

But there are quite a few non-byte addressable architectures out there. Including ARM, last I checked.

Actually, ARM cores are capable of byte addressing (at least any of the currently supported architectures).

Some ARM devices may have restrictions on certain types of memory, though.

itself. Some of them can lie dormant

Actually most architectures are byte addressable, including ARM, so casting pointers just works. Of course it's essential to know what you're doing - well written programs rarely need pointer casts.

Wilco

True, but many of them (ARM, SPARC, MSP430, ...) have alignment requirements for objects larger than 1 byte in size.

Unless the resulting pointer is misaligned.

Depends on what exactly you mean by the term.

AFAIK ARM7 is byte-addressable only for bytes, but not for larger objects. Well, may be it's just me, but I wouldn't call what happens when an ARM7 accesses a 32-bit integer without 4-byte alignment "addressing".

Well, may be it's just me, but I wouldn't

alignment "addressing".

Obviously not all possible pointer values are valid for all types. This doesn't affect byte addressability as casting between char* and int* doesn't lose information. Accessing a misaligned pointer will result in an exception (which is a good way to detect corrupted pointers). However if you use the correct type (eg. __packed int *p rather than int *p), the compiler will generate an unaligned access.

Similarly a 32-bit CPU with less than 4GB of memory doesn't have (say) a 18.25-bit address space - it still has a 32-bit address space of which only a small proportion is valid.

Wilco

Byte addressability refers to the smallest unit of addressability, not to the coursest.

Or the pointer is aligned but points to the wrong place, or invalid memory, or a peripheral, or ... If you don't know what you're doing then pointer casting is likely the least of your problems.

My point was that the bitpatterns of all pointer types are the same for all addresses in the address space.

Wilco

... snip ...

No. Pointers also carry (or imply) information about the object type, including alignment requirements. Misaligned access to an item can cause all sorts of unwelcome reactions.

One thing you can do is cast a pointer to an unsigned char*. But not the reverse. Note that you can't dereference a void*.

In C, a byte is just the smallest addressable memory unit. It must hold at least 8 bits, but it can be many more.

... snip ...

Not necessarily so. void* carries all the information, apart from the object type. void* bitpattern is identical with the char* bitpattern, but after that there are no limits.

Well, may be it's just me, but I wouldn't

alignment "addressing".

On some systems. On others you just get garbage values.

I tried to figure out how to do that using gcc, but never I seemed to get the declarations or typedefs right...

I know.

I think the disconnect is in what you meant by "just works". We assumed you meant it resulted in a pointer that could be dereferences. Apparently you meant that it could be cast to someother type, then cast back to the original type and result in the same pointer?

I see. I didn't recognize that point when it was spelled "casting just works".

You're talking about what the C language standards guarantee. I'm talking about how compilers implement the language. On a byte addressable architecture you can rely on the one I mentioned above. The fact is most programs rely on this whether the standard permits it or not...

Wilco