Start adding an integrated assembler.

src/IceUtils.h

+//===- 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
+
+#include <climits>
+
+namespace Ice {
+
+// TODO(jvoung): why are labels offset by this?
+const uint32_t kWordSize = sizeof(intptr_t);

[Jim Stichnoth, 2014/09/09 14:58:41]

It's hard to search the patchsets for uses of kWordSize, but this sounds like a
sizeof that should be for the target machine, not necessarily the machine
building llvm2ice.

[jvoung (off chromium), 2014/09/15 17:19:15]

I moved this to the one place it's being used, which is now in a target specific
file. I still need to look into why this is being used that way. There are
separate places where "+/- 4" and "+/- 1" are hard coded (imm32, imm8), while
there is also this kWordSize separate from the "4".

+
+// 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) < (CHAR_BIT * sizeof(value))));

[Jim Stichnoth, 2014/09/09 14:58:42]

Same comment as above - is this CHAR_BIT, or the target-specific X86_CHAR_BIT? 
(not that they should ever be different, but...)

[jvoung (off chromium), 2014/09/15 17:19:15]

I think this is plain CHAR_BIT, since it's used along with sizeof(T) (where T is
some type specified by the subzero code).

Since sizeof(char) is always 1, and we're trying to figure out the number of
bits, I think the multiplier should be CHAR_BIT.

+    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) < (CHAR_BIT * sizeof(value))));
+    T limit = static_cast<T>(1) << N;
+    return (0 <= value) && (value < limit);
+  }
+};
+
+} // end of namespace Ice
+
+#endif // SUBZERO_SRC_ICEUTILS_H