Add UBSAN build option and fix undefined behaviour errors.

src/IceAssembler.h

 //===- subzero/src/IceAssembler.h - Integrated assembler --------*- C++ -*-===//
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 82 matching lines @@
   AssemblerBuffer(const AssemblerBuffer &) = delete;
   AssemblerBuffer &operator=(const AssemblerBuffer &) = delete;
 
 public:
   AssemblerBuffer(Assembler &);
   ~AssemblerBuffer();
 
   /// Basic support for emitting, loading, and storing.
   template <typename T> void emit(T Value) {
     assert(hasEnsuredCapacity());
-    *reinterpret_cast<T *>(Cursor) = Value;
+    memcpy(reinterpret_cast<void *>(Cursor), &Value, sizeof(T));

[Jim Stichnoth, 2015/09/04 21:32:48]

Have you checked the effect of this patch on assembler performance?  Most of the
calls to emit() originate from emitUint8() where sizeof(T)==1.

I would assume that since sizeof(T) is always known, the compiler will be smart
enough not to actually call memcpy, especially for sizeof(T)==1, but no
guarantee.

If there is a performance difference, you could probably do
  if (sizeof(T) == 1)  /* direct copy */ ;
  else /* memcpy() */ ;
which would be less duplication than specializing the template.

Also, for future developers, leave a comment that memcpy() is to avoid
misalignment.

[ascull, 2015/09/05 00:00:48]

The binary produces is the same before and after this change. (For some reason
the binary changes after the enum stuff which I didn't expect)

The comment has been added.

[Jim Stichnoth, 2015/09/05 01:03:22]

OK, thanks for checking.

     Cursor += sizeof(T);
   }
 
   template <typename T> T load(intptr_t Position) const {
     assert(Position >= 0 &&
            Position <= (size() - static_cast<intptr_t>(sizeof(T))));
-    return *reinterpret_cast<T *>(Contents + Position);
+    T Value;
+    memcpy(&Value, reinterpret_cast<void *>(Contents + Position), sizeof(T));
+    return Value;
   }
 
   template <typename T> void store(intptr_t Position, T Value) {
     assert(Position >= 0 &&
            Position <= (size() - static_cast<intptr_t>(sizeof(T))));
-    *reinterpret_cast<T *>(Contents + Position) = Value;
+    memcpy(reinterpret_cast<void *>(Contents + Position), &Value, sizeof(T));
   }
 
   /// Emit a fixup at the current location.
   void emitFixup(AssemblerFixup *Fixup) { Fixup->set_position(size()); }
 
   /// Get the size of the emitted code.
   intptr_t size() const { return Cursor - Contents; }
   uintptr_t contents() const { return Contents; }
 
   /// To emit an instruction to the assembler buffer, the EnsureCapacity helper
@@ skipping 173 matching lines @@
 protected:
   // Buffer's constructor uses the Allocator, so it needs to appear after it.
   // TODO(jpp): dependencies on construction order are a nice way of shooting
   // yourself in the foot. Fix this.
   AssemblerBuffer Buffer;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEASSEMBLER_H_