Subzero: Add locking to prepare for multithreaded translation.

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 880 matching lines @@
   this->HasComputedFrame = true;
 
   // Assign stack offsets to variables that have been linked to spilled
   // variables.
   for (Variable *Var : VariablesLinkedToSpillSlots) {
     Variable *Linked = (llvm::cast<SpillVariable>(Var))->getLinkedTo();
     Var->setStackOffset(Linked->getStackOffset());
   }
 
   if (ALLOW_DUMP && Func->getContext()->isVerbose(IceV_Frame)) {
+    OstreamLocker L(Func->getContext());
     Ostream &Str = Func->getContext()->getStrDump();
 
     Str << "Stack layout:\n";
     uint32_t EspAdjustmentPaddingSize =
         SpillAreaSizeBytes - LocalsSpillAreaSize -
         GlobalsAndSubsequentPaddingSize - SpillAreaPaddingBytes;
     Str << " in-args = " << InArgsSizeBytes << " bytes\n"
         << " return address = " << X86_RET_IP_SIZE_BYTES << " bytes\n"
         << " preserved registers = " << PreservedRegsSizeBytes << " bytes\n"
         << " spill area padding = " << SpillAreaPaddingBytes << " bytes\n"
@@ skipping 105 matching lines @@
     (void)CharsPrinted; // avoid warnings if asserts are disabled
     Const->emitPoolLabel(Str);
     Str << ":\n\t" << T::AsmTag << "\t" << buf << "\t# " << T::TypeName << " "
         << Value << "\n";
   }
 }
 
 void TargetX8632::emitConstants() const {
   // No need to emit constants from the int pool since (for x86) they
   // are embedded as immediates in the instructions, just emit float/double.
   if (Ctx->getFlags().UseELFWriter) {

[jvoung (off chromium), 2015/01/15 18:20:40]

I think the elfwriter will also write to a stream.

[Jim Stichnoth, 2015/01/17 18:44:17]

Good point.  Lifted the locker to cover the whole method.

[Jim Stichnoth, 2015/01/20 16:22:54]

On second thought, I went back to the original change, for the same reason we
only lock the emit stream in Cfg::emitIAS() when Ctx->getFlags().UseELFWriter is
false.

[jvoung (off chromium), 2015/01/20 17:34:30]

Hmm, right... and this is only called once after joining all the threads (if the
elf-writer thread is also joined)?

[Jim Stichnoth, 2015/01/20 18:14:53]

I think this structure will have to be redone when I add threading.  There will
be 3 ways to emit code:

1. ELF emission.  The ELF emitter thread takes assembler buffers from the work
queue, and emits to the stream/file without needing a lock.

2. Old-style "readable" asm.  The translator thread grabs the emit stream lock
and executes Cfg::emit().  The ELF emitter thread does nothing.

3. Text asm with the integrated assembler (".byte" style asm).  Here I think the
ELF emitter thread will handle the text asm emission.  Since it's the only
thread doing emission, there will be no need to grab the emitter lock.

     ELFObjectWriter *Writer = Ctx->getObjectWriter();
     Writer->writeConstantPool<ConstantFloat>(IceType_f32);
     Writer->writeConstantPool<ConstantDouble>(IceType_f64);
   } else {
+    OstreamLocker L(Ctx);
     emitConstantPool<PoolTypeConverter<float>>();
     emitConstantPool<PoolTypeConverter<double>>();
   }
 }
 
 void TargetX8632::split64(Variable *Var) {
   switch (Var->getType()) {
   default:
     return;
   case IceType_i64:
@@ skipping 2519 matching lines @@
   return false;
 }
 
 void dumpAddressOpt(const Cfg *Func, const Variable *Base,
                     const Variable *Index, uint16_t Shift, int32_t Offset,
                     const Inst *Reason) {
   if (!ALLOW_DUMP)
     return;
   if (!Func->getContext()->isVerbose(IceV_AddrOpt))
     return;
+  OstreamLocker L(Func->getContext());
   Ostream &Str = Func->getContext()->getStrDump();
   Str << "Instruction: ";
   Reason->dumpDecorated(Func);
   Str << "  results in Base=";
   if (Base)
     Base->dump(Func);
   else
     Str << "<null>";
   Str << ", Index=";
   if (Index)
@@ skipping 151 matching lines @@
     Reason = BaseInst;
     return true;
   }
   return false;
 }
 
 void computeAddressOpt(Cfg *Func, const Inst *Instr, Variable *&Base,
                        Variable *&Index, uint16_t &Shift, int32_t &Offset) {
   Func->resetCurrentNode();
   if (Func->getContext()->isVerbose(IceV_AddrOpt)) {
+    OstreamLocker L(Func->getContext());
     Ostream &Str = Func->getContext()->getStrDump();
     Str << "\nStarting computeAddressOpt for instruction:\n  ";
     Instr->dumpDecorated(Func);
   }
   (void)Offset; // TODO: pattern-match for non-zero offsets.
   if (Base == nullptr)
     return;
   // If the Base has more than one use or is live across multiple
   // blocks, then don't go further.  Alternatively (?), never consider
   // a transformation that would change a variable that is currently
@@ skipping 821 matching lines @@
     std::random_shuffle(Shuffled.begin(), Shuffled.end(), RNG);
     for (size_t SI = 0, SE = Shuffled.size(); SI < SE; ++SI) {
       Permutation[List[SI]] = Shuffled[SI];
       ++NumShuffled;
     }
   }
 
   assert(NumShuffled + NumPreserved == RegX8632::Reg_NUM);
 
   if (Func->getContext()->isVerbose(IceV_Random)) {
+    OstreamLocker L(Func->getContext());
     Ostream &Str = Func->getContext()->getStrDump();
     Str << "Register equivalence classes:\n";
     for (auto I : EquivalenceClasses) {
       Str << "{";
       const RegisterList &List = I.second;
       bool First = true;
       for (int32_t Register : List) {
         if (!First)
           Str << " ";
         First = false;
@@ skipping 126 matching lines @@
   } else if (IsConstant || IsExternal)
     Str << "\t.zero\t" << Size << "\n";
   // Size is part of .comm.
 
   if (IsConstant || HasNonzeroInitializer || IsExternal)
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   // Size is part of .comm.
 }
 
 } // end of namespace Ice