Subzero: Add locking to prepare for multithreaded translation.

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        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 Cfg class, including constant pool
@@ skipping 38 matching lines @@
   // TODO(stichnot,kschimpf): Set CurrentCfg=nullptr in the dtor for
   // safety.  This can't be done currently because the translator
   // manages the Cfg by creating a new Cfg (which sets CurrentCfg to
   // the new value), then deleting the old Cfg (which would then reset
   // CurrentCfg to nullptr).
 }
 
 void Cfg::setError(const IceString &Message) {
   HasError = true;
   ErrorMessage = Message;
+  OstreamLocker L(Ctx);
   Ctx->getStrDump() << "ICE translation error: " << ErrorMessage << "\n";
 }
 
 CfgNode *Cfg::makeNode() {
   SizeT LabelIndex = Nodes.size();
   CfgNode *Node = CfgNode::create(this, LabelIndex);
   Nodes.push_back(Node);
   return Node;
 }
 
@@ skipping 259 matching lines @@
       Node->livenessAddIntervals(getLiveness(), FirstInstNum, LastInstNum);
     }
   }
 }
 
 // Traverse every Variable of every Inst and verify that it
 // appears within the Variable's computed live range.
 bool Cfg::validateLiveness() const {
   TimerMarker T(TimerStack::TT_validateLiveness, this);
   bool Valid = true;
+  OstreamLocker L(Ctx);
   Ostream &Str = Ctx->getStrDump();
   for (CfgNode *Node : Nodes) {
     Inst *FirstInst = nullptr;
     for (Inst &Inst : Node->getInsts()) {
       if (Inst.isDeleted())
         continue;
       if (FirstInst == nullptr)
         FirstInst = &Inst;
       InstNumberT InstNumber = Inst.getNumber();
       if (Variable *Dest = Inst.getDest()) {
@@ skipping 87 matching lines @@
 void Cfg::emit() {
   if (!ALLOW_DUMP)
     return;
   TimerMarker T(TimerStack::TT_emit, this);
   if (Ctx->getFlags().DecorateAsm) {
     renumberInstructions();
     getVMetadata()->init(VMK_Uses);
     liveness(Liveness_Basic);
     dump("After recomputing liveness for -decorate-asm");
   }
+  OstreamLocker L(Ctx);
   Ostream &Str = Ctx->getStrEmit();
   IceString MangledName = getContext()->mangleName(getFunctionName());
   emitTextHeader(MangledName);
   for (CfgNode *Node : Nodes)
     Node->emit(this);
   Str << "\n";
 }
 
 void Cfg::emitIAS() {
   TimerMarker T(TimerStack::TT_emit, this);
   assert(!Ctx->getFlags().DecorateAsm);
   IceString MangledName = getContext()->mangleName(getFunctionName());
+  OstreamLocker L(Ctx);
   if (!Ctx->getFlags().UseELFWriter)

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

Technically, the lock doesn't need to be held this long. The loop through
CfgNodes can be done without the lock, and just the emitTextHeader /
writeFunctionCode and emitIASBytes need it.

It might be okay to do the loop first, and move the emitTextHeader to be after,
since the .s fallback only writes in bulk via emitIASBytes.

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

Done.

     emitTextHeader(MangledName);
   for (CfgNode *Node : Nodes)
     Node->emitIAS(this);
   // Now write the function to the file and track.
   if (Ctx->getFlags().UseELFWriter) {
     getAssembler<Assembler>()->alignFunction();
     Ctx->getObjectWriter()->writeFunctionCode(MangledName, getInternal(),
                                               getAssembler<Assembler>());
   } else {
     getAssembler<Assembler>()->emitIASBytes(Ctx);
   }
 }
 
 // Dumps the IR with an optional introductory message.
 void Cfg::dump(const IceString &Message) {
   if (!ALLOW_DUMP)
     return;
   if (!Ctx->isVerbose())
     return;
+  OstreamLocker L(Ctx);
   Ostream &Str = Ctx->getStrDump();
   if (!Message.empty())
     Str << "================ " << Message << " ================\n";
   setCurrentNode(getEntryNode());
   // Print function name+args
   if (getContext()->isVerbose(IceV_Instructions)) {
     Str << "define ";
     if (getInternal() && !Ctx->getFlags().DisableInternal)
       Str << "internal ";
     Str << ReturnType << " @" << Ctx->mangleName(getFunctionName()) << "(";
@@ skipping 20 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (getContext()->isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice