Start adding an integrated assembler.

src/IceUtils.h

Index: src/IceUtils.h
diff --git a/src/IceUtils.h b/src/IceUtils.h
new file mode 100644
index 0000000000000000000000000000000000000000..acb409cdd77bd5760d877ec40037c46d64128445
--- /dev/null
+++ b/src/IceUtils.h
@@ -0,0 +1,58 @@
+//===- subzero/src/IceUtils.h - Utility functions ---------------*- C++ -*-===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file declares some utility functions
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SUBZERO_SRC_ICEUTILS_H
+#define SUBZERO_SRC_ICEUTILS_H
+
+namespace Ice {
+
+// The number of bits in a byte...
+// TODO(jvoung): de-duplicate this?
+const uint32_t kBitsPerByte = 8;

[Jim Stichnoth, 2014/09/04 20:57:48]

C++ CHAR_BIT for translator-time uses, and we also have X86_CHAR_BIT for runtime
uses.

[jvoung (off chromium), 2014/09/08 21:39:00]

Done. I removed one use that wasn't used, and adjusted some asserts.

In this case, I think it's translator side since it's used to multiply a
translator-side sizeof(T).

+
+const uint32_t kWordSize = sizeof(uint32_t);

[Jim Stichnoth, 2014/09/04 20:57:48]

Make it clear whether this is translator-time or runtime usage?  Though it's
hard to imagine the sizes being different.

[jvoung (off chromium), 2014/09/08 21:39:00]

Hmm, I need to look into this more. Maybe this shouldn't be in the general
IceUtils.h.  It's actually sizeof(intptr_t) originally, so it would have been
different for x86-64.

For the x86-32 assembler, it is only used for Label positions (for some reason,
offset them by kWordSize which is 4 or 8). I'm not sure exactly why this is used
to offset Label positions. It's not like it is based on instruction size or size
of disp32 or anything (since it's either 4 or 8).

For the x86-64 assembler, it's also used to represent the size of a 64-bit
register...

I'd like to leave a TODO until I start assembling jumps. It seems like we should
have different constants for the different cases. E.g., we don't want to
conflate size of 64-bit register w/ size of pointer.

+
+// Similar to bit_cast, but allows copying from types of unrelated
+// sizes. This method was introduced to enable the strict aliasing
+// optimizations of GCC 4.4. Basically, GCC mindlessly relies on
+// obscure details in the C++ standard that make reinterpret_cast
+// virtually useless.
+template <class D, class S> inline D bit_copy(const S &source) {
+  D destination;
+  // This use of memcpy is safe: source and destination cannot overlap.
+  memcpy(&destination, reinterpret_cast<const void *>(&source),
+         sizeof(destination));
+  return destination;
+}
+
+class Utils {
+public:
+  // Check whether an N-bit two's-complement representation can hold value.
+  template <typename T> static inline bool IsInt(int N, T value) {
+    assert((0 < N) &&
+           (static_cast<unsigned int>(N) < (kBitsPerByte * sizeof(value))));
+    T limit = static_cast<T>(1) << (N - 1);
+    return (-limit <= value) && (value < limit);
+  }
+
+  template <typename T> static inline bool IsUint(int N, T value) {
+    assert((0 < N) &&
+           (static_cast<unsigned int>(N) < (kBitsPerByte * sizeof(value))));
+    T limit = static_cast<T>(1) << N;
+    return (0 <= value) && (value < limit);
+  }
+};
+
+} // end of namespace Ice
+
+#endif // SUBZERO_SRC_ICEUTILS_H