Subzero: Fix nondeterministic behavior in constant pool creation.

src/IceTargetLoweringARM32.cpp

 //===- subzero/src/IceTargetLoweringARM32.cpp - ARM32 lowering ------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 3132 matching lines @@
       assert(isScalarFloatingType(Ty));
       // Load floats/doubles from literal pool.
       // TODO(jvoung): Allow certain immediates to be encoded directly in an
       // operand. See Table A7-18 of the ARM manual: "Floating-point modified
       // immediate constants". Or, for 32-bit floating point numbers, just
       // encode the raw bits into a movw/movt pair to GPR, and vmov to an SREG,
       // instead of using a movw/movt pair to get the const-pool address then
       // loading to SREG.
       std::string Buffer;
       llvm::raw_string_ostream StrBuf(Buffer);
-      llvm::cast<Constant>(From)->emitPoolLabel(StrBuf);
+      llvm::cast<Constant>(From)->emitPoolLabel(StrBuf, Ctx);
       llvm::cast<Constant>(From)->setShouldBePooled(true);
       Constant *Offset = Ctx->getConstantSym(0, StrBuf.str(), true);
       Variable *BaseReg = makeReg(getPointerType());
       _movw(BaseReg, Offset);
       _movt(BaseReg, Offset);
       From = formMemoryOperand(BaseReg, Ty);
       return copyToReg(From, RegNum);
     }
   }
 
@@ skipping 187 matching lines @@
     static_assert(sizeof(double) == sizeof(uint64_t),
                   "Double should be 8 bytes.");
     return *reinterpret_cast<uint64_t *>(&Value);
   }
 };
 const char ConstantPoolEmitterTraits<double>::AsmTag[] = ".quad";
 const char ConstantPoolEmitterTraits<double>::TypeName[] = "f64";
 
 template <typename T>
 void emitConstant(
-    Ostream &Str,
+    Ostream &Str, const GlobalContext *Ctx,
     const typename ConstantPoolEmitterTraits<T>::ConstantType *Const) {
   using Traits = ConstantPoolEmitterTraits<T>;
-  Const->emitPoolLabel(Str);
+  Const->emitPoolLabel(Str, Ctx);
   Str << ":\n\t" << Traits::AsmTag << "\t0x";
   T Value = Const->getValue();
   Str.write_hex(Traits::bitcastToUint64(Value));
   Str << "\t@" << Traits::TypeName << " " << Value << "\n";
 }
 
 template <typename T> void emitConstantPool(GlobalContext *Ctx) {
   if (!BuildDefs::dump()) {
     return;
   }
@@ skipping 12 matching lines @@
   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));
+    emitConstant<T>(Str, Ctx, llvm::dyn_cast<typename Traits::ConstantType>(C));
   }
 }
 } // end of anonymous namespace
 
 void TargetDataARM32::lowerConstants() {
   if (Ctx->getFlags().getDisableTranslation())
     return;
   switch (Ctx->getFlags().getOutFileType()) {
   case FT_Elf:
     UnimplementedError(Ctx->getFlags());
@@ skipping 71 matching lines @@
       << ".eabi_attribute 68, 1   @ Tag_Virtualization_use\n";
   if (CPUFeatures.hasFeature(TargetARM32Features::HWDivArm)) {
     Str << ".eabi_attribute 44, 2   @ Tag_DIV_use\n";
   }
   // Technically R9 is used for TLS with Sandboxing, and we reserve it.
   // However, for compatibility with current NaCl LLVM, don't claim that.
   Str << ".eabi_attribute 14, 3   @ Tag_ABI_PCS_R9_use: Not used\n";
 }
 
 } // end of namespace Ice