Builtin MemCpy Chk will always overflow destination buffer - ios

Question

Updating my app from 32-bit to 64-bit.
According to the Apple Documentation floats are only 4 byte and I need to use CGFloat (8 byte)
I am using the memcpy to read in bytes. I have updated all my sizeof(float)s to sizeof(CGFloat).
But when I do I get the Semantic issue
__builtin___memcpy_chk will always overflow destination buffer. Expanded from macro memcpy
I updated my NSData readDataOfLenght to take sizeof(CGFloat) and it seems to work ok. Sometimes not all the data that is read in is correct.
I am afraid I am over my head in this and could use some help.
-(void) readByteData:(NSFileHandle *)fHandle Size:(NSInteger)byteSize
{
[super readByteData:fHandle Size:byteSize];
NSData *data = [fHandle readDataOfLength:sizeof(CGFloat)];
float r;
memcpy(&r, [data bytes], sizeof(CGFloat));
self.radius = r;
int nCGPointSize = sizeof(CGFloat) * 2;
data = [fHandle readDataOfLength:nCGPointSize];
float xy[2];
memcpy(xy, [data bytes], nCGPointSize);
self.centerPos = ccp(xy[0], xy[1]);
data = [fHandle readDataOfLength:sizeof(CGFloat)];
float start_angle;
memcpy(&start_angle, [data bytes], sizeof(CGFloat));
self.startAngle = start_angle;
data = [fHandle readDataOfLength:sizeof(CGFloat)];
float end_angle;
memcpy(&end_angle, [data bytes], sizeof(CGFloat));
self.endAngle = end_angle;
data = [fHandle readDataOfLength:sizeof(int)];
int d;
memcpy(&d, [data bytes], sizeof(int));
self.dir = d;
flagClosed = YES;
}

Answer 1

This instruction:
float r;
memcpy(&r, [data bytes], sizeof(CGFloat));
Tells your compiler:
Read sizeof(CGFloat) (== 8 bytes!) from the location [data bytes]
and write them to r
But r is only 4 bytes in size! So the first 4 bytes are written to r and the next 4 bytes are written to whatever follows r in memory and this is not allowed. memcpy is a simple byte copy instructions, it moves any number of bytes from memory location A to memory location B, it cannot convert data types for you. If you need to convert CGFloat values to float values, then you actually need to do that conversion yourself.
CGFloat bigR;
memcpy(&bigR, [data bytes], sizeof(bigR));
self.radius = (float)bigR;
Same when reading multiple values:
CGFloat bigXY[2];
data = [fHandle readDataOfLength:sizeof(bigXY)];
memcpy(bigXY, [data bytes], sizeof(bigXY));
self.centerPos = ccp((float)bigXY[0], (float)bixXY[1]);
The casts are only to make it more clear where the conversion takes place, most compilers will also compile the code without all the (float) casts and without complaining.
As a general rule:
memcpy(dst, src, size)
size must never be bigger than the memory src points to or the memory dst points to. In your case, size was always bigger than the memory dst pointed to.
So far the explanation why your code didn't work. However, you actually don't need to use memcpy at all as if you have a memory block out of multiple values of a known data type, of course you can access that memory directly without having to copy it anywhere:
NSData * data = [fHandle readDataOfLength:sizeof(CGFloat)];
if (!data) {
// ... handle errorr ...
}
const CGFloat * cgfloatsInData = (const CGFloat *)[data bytes];
self.radius = (float)cgfloatsInData[0];
data = [fHandle readDataOfLength:sizeof(CGFloat) * 2];
if (!data) {
// ... handle errorr ...
}
const CGFloat * cgfloatsInData = (const CGFloat *)[data bytes];
self.centerPos = ccp((float)cgfloatsInData[0], (float)cgfloatsInData[1]);
And so on. But this is highly inefficient, as you seem to always expect some fixed size structure with no optional values, so why not reading it as a structure? That way you only need one I/O access to read all of it and only one NSData object must be created by the system.
const struct {
CGFloat radius;
CGFloat xCoord;
CGFloat yCoord;
CGFloat startAngle;
CGFloat endAngle;
int dir;
} __attribute__((packed)) * entry;
// `const` as the memory `entry` will point to will be read-only.
// `* entry` means entry is a pointer to memory of a struct
// that looks as described above. __attribute__((packed)) means
// the memory must be laid out exactly as shown above and have no
// padding for better alignment of fields.
NSData * data = [fHandle readDataOfLength:sizeof(*entry)];
// `sizeof(*entry)` means the size of the memory entry points to,
// contrary to `sizeof(entry)` which would be the size of entry itself
// and that would simply be the size of a pointer on your system, 8 bytes,
// whereas `sizeof(*entry)` will be 44 bytes.
entry = (const void *)dataBytes;
// Any pointer type can be cased to `void *` and assigning
// a `void *` pointer so some pointer is always allowed by the compiler.
self.radius = (float)entry->radius;
self.centerPos = ccp((float)entry->xCoord, (float)entry->yCoord);
self.startAngle = (float)entry->startAngle;
self.endAngle = (float)entry->endAngle;
self.dir = entry->dir;