Why are structures copied via memcpy in embedded system code?

Question

In embedded software domain for copying structure of same type people don't use direct assignment and do that by memcpy() function or each element copying.

lets have for example

struct tag
{

int a;

int b;
};

struct tag exmple1 = {10,20};

struct tag exmple2;

for copying exmple1 into exmple2.. instead of writing direct

exmple2=exmple1;

people use

memcpy(exmple2,exmple1,sizeof(struct tag));

or

exmple2.a=exmple1.a; 
exmple2.b=exmple1.b;

why ????

Answer 1

One way or the other there is nothing specific about embedded systems that makes this dangerous, the language semantics are identical for all platforms.

C has been used in embedded systems for many years, and early C compilers, before ANSI/ISO standardisation did not support direct structure assignment. Many practitioners are either from that era, or have been taught by those that were, or are using legacy code written by such practitioners. This is probably the root of the doubt, but it is not a problem on an ISO compliant implementation. On some very resource constrained targets, the available compiler may not be fully ISO compliant for a number of reasons, but I doubt that this feature would be affected.

One issue (that applies to embedded and non-embedded alike), is that when assigning a structure, an implementation need not duplicate the value of any undefined padding bits, therefore if you performed a structure assignment, and then performed a memcmp() rather than member-by-member comparison to test for equality, there is no guarantee that they will be equal. However if you perform a memcpy(), any padding bits will be copied so that memcmp() and member-by-member comparison will yield equality.

So it is arguably safer to use memcpy() in all cases (not just embedded), but the improvement is marginal, and not conducive to readability. It would be a strange implementation that did not use the simplest method of structure assignment, and that is a simple memcpy(), so it is unlikely that the theoretical mismatch would occur.

Answer 2

In your given code there is no problem even if you write:

example2 = example1;

But just assume if in future, the struct definition changes to:

struct tag
{
  int a[1000];
  int b;
};

Now if you execute the assignment operator as above then (some of the) compiler might inline the code for byte by byte (or int by int) copying. i.e.

example1.a[0] = example.a[0];
example1.a[1] = example.a[1];
example1.a[2] = example.a[2];
...

which will result in code bloat in your code segment. Such kind of memory errors are not trivial to find. That's why people use memcpy.

[However, I have heard that modern compilers are capable enough to use memcpy internally when such instruction is encountered especially for PODs.]