Subzero. Implements TargetDataARM32::lowerConstants.

src/IceTargetLoweringARM32.cpp

Index: src/IceTargetLoweringARM32.cpp
diff --git a/src/IceTargetLoweringARM32.cpp b/src/IceTargetLoweringARM32.cpp
index 8a0ebec9a50fb3d5f2ef3ec17bd27a09fe9d0d8a..15e68d175203d516fead9f3493cf774ca3f3fd36 100644
--- a/src/IceTargetLoweringARM32.cpp
+++ b/src/IceTargetLoweringARM32.cpp
@@ -29,6 +29,8 @@
 #include "IceUtils.h"
 #include "llvm/Support/MathExtras.h"
 
+#include <algorithm>
+
 namespace Ice {
 
 namespace {
@@ -3148,16 +3150,125 @@ void TargetDataARM32::lowerGlobals(const VariableDeclarationList &Vars,
   }
 }
 
+namespace {
+template <typename T> struct ConstantPoolEmitterTraits;
+
+static_assert(sizeof(unsigned long long) == 8,

[Jim Stichnoth, 2015/09/18 13:59:34]

Can you use uint64_t instead of unsigned long long?

[John, 2015/09/18 14:20:25]

Sometimes you might run into problems with uint64_t. This is not one of those,
some i don't really care either way. Done.

+              "unsigned long long is supposed to be 8 bytes wide.");
+
+// TODO(jpp): implement the following when implementing constant randomization:
+//  * template <> struct ConstantPoolEmitterTraits<uint8_t>
+//  * template <> struct ConstantPoolEmitterTraits<uint16_t>
+//  * template <> struct ConstantPoolEmitterTraits<uint32_t>
+template <> struct ConstantPoolEmitterTraits<float> {
+  using ConstantType = ConstantFloat;
+  static constexpr Type IceType = IceType_f32;
+  // AsmTag and TypeName can't be constexpr because llvm::StringRef is unhappy
+  // about them being constexpr.
+  static const char AsmTag[];
+  static const char TypeName[];
+  static unsigned long long bitcastToUint64(float Value) {
+    static_assert(sizeof(Value) == sizeof(uint32_t),
+                  "Float should be 4 bytes.");
+    uint32_t IntValue = *reinterpret_cast<uint32_t *>(&Value);
+    return static_cast<unsigned long long>(IntValue);
+  }
+};
+const char ConstantPoolEmitterTraits<float>::AsmTag[] = ".long";
+const char ConstantPoolEmitterTraits<float>::TypeName[] = "f32";
+
+template <> struct ConstantPoolEmitterTraits<double> {
+  using ConstantType = ConstantDouble;
+  static constexpr Type IceType = IceType_f64;
+  static const char AsmTag[];
+  static const char TypeName[];
+  static unsigned long long bitcastToUint64(double Value) {
+    static_assert(sizeof(double) == sizeof(unsigned long long),
+                  "Double should be 8 bytes.");
+    return *reinterpret_cast<unsigned long long *>(&Value);
+  }
+};
+const char ConstantPoolEmitterTraits<double>::AsmTag[] = ".quad";
+const char ConstantPoolEmitterTraits<double>::TypeName[] = "f64";
+
+template <typename T>
+void emitConstant(
+    Ostream &Str,
+    const typename ConstantPoolEmitterTraits<T>::ConstantType *Const) {
+  using Traits = ConstantPoolEmitterTraits<T>;
+  Const->emitPoolLabel(Str);
+  Str << ":\n\t" << Traits::AsmTag << "\t0x";
+  T Value = Const->getValue();
+  Str.write_hex(Traits::bitcastToUint64(Value));
+  Str << "\t@" << Traits::TypeName << " " << Value << "\n";

[Jim Stichnoth, 2015/09/18 13:59:34]

Optional: It would be cool if, as an end-of-line comment, you could also print
the non-hex FP representation of the constant.

[John, 2015/09/18 14:20:25]

I am already printing the actual FP value (e.g., 1.0). Do you mean outputting
something like:

.quad 0x100  @ double 256
?

If so, then why?

[Jim Stichnoth, 2015/09/18 15:39:59]

Oh, whoops, sorry.
(sometimes I do prefer printf style format strings...)

[John, 2015/09/18 15:42:28]

I always prefer printf format string -- they are more readable. But this
implementation is more efficient (and not awfully unreadable -- just a tad bit
:) )

+}
+
+template <typename T> void emitConstantPool(GlobalContext *Ctx) {
+  if (!BuildDefs::dump()) {
+    return;
+  }
+
+  using Traits = ConstantPoolEmitterTraits<T>;
+  SizeT Align =
+      std::max(static_cast<size_t>(4), typeAlignInBytes(Traits::IceType));

[Jim Stichnoth, 2015/09/18 13:59:34]

First, I don't like magic constants like "4" sprinkled in the code.

Second, why make 4 the minimum alignment?  Can't an i16 constant pool be aligned
at 2-byte boundaries?

[John, 2015/09/18 14:20:25]

1) I avoid magic constants, too. However, this is way clearer (to me) than

static constexpr uint32_t MinimumWordAlign = 4;
std::max(MinimumWordAlign, typeAlignInBytes());

Named constants help a lot when the parameter is something "funny-looking" for
what you're trying to accomplish. (e.g. the far jump parameter on the X86
Assembler, which is a boolean -- it should have been an enum, at least.) In this
case, having a named constant just hides what the actual alignment is (plus, I
personally dislike the std::max(Minimum, Align(Type));

2) unaligned accesses are not guaranteed not to fault. As of right now, we
always (AFAIK) use a ldr (instead of the ldrb, ldrH variants), which would fault
if a magical alignment check bit is set (Murphy states that, if we allow
unaligned access, that bit will cause the program to fault.) Plus, because ARM,
everything is already so slow that I would like to prevent unaligned accesses.

[Jim Stichnoth, 2015/09/18 15:39:59]

I see, thanks.

+  assert((Align % 4) == 0 && "Constants should be aligned");
+  Ostream &Str = Ctx->getStrEmit();
+  ConstantList Pool = Ctx->getConstantPool(Traits::IceType);
+
+  Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",%progbits," << Align
+      << "\n"
+      << "\t.align\t" << Align << "\n";
+
+  if (Ctx->getFlags().shouldReorderPooledConstants()) {
+    // TODO(jpp): add constant pooling.
+    UnimplementedError(Ctx->getFlags());
+  }
+
+  for (Constant *C : Pool) {
+    if (!C->getShouldBePooled()) {
+      continue;
+    }
+
+    emitConstant<T>(Str, llvm::dyn_cast<typename Traits::ConstantType>(C));
+  }
+}
+} // end of anonymous namespace
+
 void TargetDataARM32::lowerConstants() {
   if (Ctx->getFlags().getDisableTranslation())
     return;
-  UnimplementedError(Ctx->getFlags());
+  switch (Ctx->getFlags().getOutFileType()) {
+  case FT_Elf:
+    UnimplementedError(Ctx->getFlags());
+    break;
+  case FT_Asm: {
+    OstreamLocker L(Ctx);
+    emitConstantPool<float>(Ctx);
+    emitConstantPool<double>(Ctx);
+    break;
+  }
+  case FT_Iasm: {
+    UnimplementedError(Ctx->getFlags());
+    break;
+  }
+  }
 }
 
 void TargetDataARM32::lowerJumpTables() {
   if (Ctx->getFlags().getDisableTranslation())
     return;
-  UnimplementedError(Ctx->getFlags());
+  switch (Ctx->getFlags().getOutFileType()) {
+  case FT_Elf:
+    UnimplementedError(Ctx->getFlags());
+    break;
+  case FT_Asm:
+    // Already emitted from Cfg
+    break;
+  case FT_Iasm: {
+    UnimplementedError(Ctx->getFlags());
+    break;
+  }
+  }
 }
 
 TargetHeaderARM32::TargetHeaderARM32(GlobalContext *Ctx)