title: How to safely perform type-punning in embedded system
body: <p>Our team is currently using some ported code from an old architecture to a new product based on the ARM Cortex M3 platform using a customized version of GCC 4.5.1. We are reading data from a communications link, and attempting to cast the raw byte array to a struct to cleanly parse the data. After casting the pointer to a struct and dereferencing, we are getting a warning: "dereferencing type-punned pointer will break strict-aliasing rules".</p>
  
  <p>After some research, I've realized that since the char array has no alignment rules and the struct have to be word aligned, casting the pointers causes undefined behavior (a Bad Thing). I'm wondering if there is a better way to do what we're trying.</p>
  
  <p>I know we can explicitly word-align the char array using GCC's "<strong>attribute</strong> ((aligned (4)))". I believe this will make our code "safer", but the warnings will still clutter up our builds, and I don't want to disable the warnings in case this situation arises again. What we want is a way to safely do what we are trying, that will still inform us if we attempt to do something unsafe in another place later. Since this is an embedded system, RAM  usage and flash usage are important to some degree.</p>
  
  <p>Portability (compiler and architecture) is not a huge concern, this is just for one product. However, if a portable solution exists, it would be preferred.</p>
  
  <p>Here is the a (very simplified) example of what we are currently doing:</p>
  
  <pre><code>#define MESSAGE_TYPE_A 0
  #define MESSAGE_TYPE_B 1
  
  typedef struct MessageA __attribute__((__packed__))
  {
      unsigned char  messageType;
      unsigned short data1;
      unsigned int   data2;
  }
  
  typedef struct MessageB __attribute__((__packed__))
  {
      unsigned char  messageType;
      unsigned char  data3;
      unsigned char  data4;
  }
  
  
  // This gets filled by the comm system, assume from a UART interrupt or similar
  unsigned char data[100];
  
  
  // Assume this gets called once we receive a full message
  void ProcessMessage()
  {
      MessageA* messageA;
      unsigned char messageType = data[0];
  
      if (messageType == MESSAGE_TYPE_A)
      {
          // Cast data to struct and attempt to read
          messageA = (MessageA*)data; // Not safe since data may not be word aligned
                                      // This may cause undefined behavior
  
          if (messageA-&gt;data1 == 4) // warning would be here, when we use the data at the pointer
          {
              // Perform some action...
          }
      }
      // ...
      // process different types of messages
  }
  </code></pre>