Subzero: Fix x86 floating-point constant emission

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 544 matching lines @@
   for (SizeT i = 0; i < CalleeSaves.size(); ++i) {
     SizeT j = CalleeSaves.size() - i - 1;
     if (j == Reg_ebp && IsEbpBasedFrame)
       continue;
     if (CalleeSaves[j] && RegsUsed[j]) {
       _pop(getPhysicalRegister(j));
     }
   }
 }
 
+void TargetX8632::emitConstants() const {
+  Ostream &Str = Ctx->getStrEmit();
+  SizeT Align;
+  Type Ty;
+  ConstantList Pool;
+
+  // Emit constants from the float pool.
+  Ty = IceType_f32;
+  Pool = Ctx->getConstantPool(Ty);
+  Align = typeAlignInBytes(Ty);
+  Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",@progbits," << Align
+      << "\n";
+  Str << "\t.align\t" << Align << "\n";
+  for (ConstantList::const_iterator I = Pool.begin(), E = Pool.end(); I != E;
+       ++I) {
+    ConstantFloat *Const = llvm::cast<ConstantFloat>(*I);
+    float Value = Const->getValue();
+    // Use memcpy() to copy bits from Value into RawValue in a way
+    // that avoids breaking strict-aliasing rules.
+    uint32_t RawValue;
+    memcpy(&RawValue, &Value, sizeof(Value));
+    Str << "L$" << Ty << "$" << Const->getPoolEntryID() << ":\n";
+    Str << "\t.long\t" << RawValue << "\t# float " << Value << "\n";

[JF, 2014/05/22 21:39:47]

Can you use hex format for .long? It would be more readable.

[Jim Stichnoth, 2014/05/22 23:48:28]

Done.

+  }
+
+  // Emit constants from the float pool.
+  Ty = IceType_f64;
+  Pool = Ctx->getConstantPool(Ty);
+  Align = typeAlignInBytes(Ty);
+  Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",@progbits," << Align
+      << "\n";
+  Str << "\t.align\t" << Align << "\n";
+  for (ConstantList::const_iterator I = Pool.begin(), E = Pool.end(); I != E;
+       ++I) {
+    ConstantDouble *Const = llvm::cast<ConstantDouble>(*I);
+    double Value = Const->getValue();
+    // Use memcpy() to copy bits from Value into RawValue in a way
+    // that avoids breaking strict-aliasing rules.
+    uint64_t RawValue;
+    memcpy(&RawValue, &Value, sizeof(Value));
+    Str << "L$" << Ty << "$" << Const->getPoolEntryID() << ":\n";
+    Str << "\t.quad\t" << RawValue << "\t# double " << Value << "\n";
+  }

[JF, 2014/05/22 21:39:47]

Those two functions are pretty much the same thing. Seems like template magic
could make the differences more apparent, and less code overall.

[Jim Stichnoth, 2014/05/22 23:48:28]

Done.  Probably break-even in terms of LOC, but still good.

+
+  // No need to emit constants from the int pool since they are
+  // embedded as immediates in the instructions.

[JF, 2014/05/22 21:39:47]

That won't always be true on ARM.

[Jim Stichnoth, 2014/05/22 23:48:28]

Yes, but this is in a file with X86 in its name. :)

I added x86 to the comment.

BTW, this may be a place where we could randomize the code by sometimes using an
immediate integer, and sometimes using a pool entry.

+}
+
 void TargetX8632::split64(Variable *Var) {
   switch (Var->getType()) {
   default:
     return;
   case IceType_i64:
   // TODO: Only consider F64 if we need to push each half when
   // passing as an argument to a function call.  Note that each half
   // is still typed as I32.
   case IceType_f64:
     break;
@@ skipping 1296 matching lines @@
         }
         assert(AvailableTypedRegisters.any());
         int32_t RegNum = AvailableTypedRegisters.find_first();
         Var->setRegNum(RegNum);
         AvailableRegisters[RegNum] = false;
       }
     }
   }
 }
 
+template <> void ConstantFloat::emit(const Cfg *Func) const {
+  Ostream &Str = Func->getContext()->getStrEmit();
+  // It would be better to prefix with ".L$" instead of "L$", but
+  // llvm-mc doesn't parse "dword ptr [.L$foo]".
+  Str << "dword ptr [L$" << IceType_f32 << "$" << getPoolEntryID() << "]";
+}
+
+template <> void ConstantDouble::emit(const Cfg *Func) const {
+  Ostream &Str = Func->getContext()->getStrEmit();
+  Str << "qword ptr [L$" << IceType_f64 << "$" << getPoolEntryID() << "]";
+}
+
 } // end of namespace Ice