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 79 matching lines @@
 
 /// Assembler buffers are used to emit binary code. They grow on demand.
 class AssemblerBuffer {
   AssemblerBuffer(const AssemblerBuffer &) = delete;
   AssemblerBuffer &operator=(const AssemblerBuffer &) = delete;
 
 public:
   AssemblerBuffer(Assembler &);
   ~AssemblerBuffer();
 
-  /// Basic support for emitting, loading, and storing.
+  /// \name Basic support for emitting, loading, and storing.
+  /// @{
+  // These use memcpy instead of assignment to avoid undefined behaviour of
+  // assigning to unaligned addresses. Since the size of the copy is known the
+  // compiler can inline the memcpy with simple moves.
   template <typename T> void emit(T Value) {
     assert(hasEnsuredCapacity());
-    *reinterpret_cast<T *>(Cursor) = Value;
+    memcpy(reinterpret_cast<void *>(Cursor), &Value, sizeof(T));
     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
   /// must be used to guarantee that the underlying data area is big enough to
@@ skipping 172 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_