First attempt to capture parser/translation errors in browser.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares aspects of the compilation that persist across
@@ skipping 127 matching lines @@
     ThreadContext &operator=(const ThreadContext &) = delete;
 
   public:
     ThreadContext() {}
     CodeStats StatsFunction;
     CodeStats StatsCumulative;
     TimerList Timers;
   };
 
 public:
-  GlobalContext(Ostream *OsDump, Ostream *OsEmit, ELFStreamer *ELFStreamer,
-                const ClFlags &Flags);
+  // The dump stream is a log stream while emit is the stream code
+  // is emitted to. The error stream is strictly for logging errors.
+  GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
+                ELFStreamer *ELFStreamer, const ClFlags &Flags);
   ~GlobalContext();
 
-  // The dump and emit streams need to be used by only one thread at a
-  // time.  This is done by exclusively reserving the streams via
-  // lockStr() and unlockStr().  The OstreamLocker class can be used
-  // to conveniently manage this.
+  //
+  // The dump, error, and emit streams need to be used by only one
+  // thread at a time.  This is done by exclusively reserving the
+  // streams via lockStr() and unlockStr().  The OstreamLocker class
+  // can be used to conveniently manage this.
   //
   // The model is that a thread grabs the stream lock, then does an
   // arbitrary amount of work during which far-away callees may grab
   // the stream and do something with it, and finally the thread
   // releases the stream lock.  This allows large chunks of output to
   // be dumped or emitted without risking interleaving from multiple
   // threads.
   void lockStr() { StrLock.lock(); }
   void unlockStr() { StrLock.unlock(); }
   Ostream &getStrDump() { return *StrDump; }
+  Ostream &getStrError() { return *StrError; }
   Ostream &getStrEmit() { return *StrEmit; }
 
   LockedPtr<ErrorCode> getErrorStatus() {
     return LockedPtr<ErrorCode>(&ErrorStatus, &ErrorStatusLock);
   }
 
   // When emitting assembly, we allow a string to be prepended to
   // names of translated functions.  This makes it easier to create an
   // execution test against a reference translator like llc, with both
   // translators using the same bitcode as input.
@@ skipping 235 matching lines @@
   // Managed by getTimers()
   GlobalLockType TimerLock;
   TimerList Timers;
 
   ICE_CACHELINE_BOUNDARY;
   // StrLock is a global lock on the dump and emit output streams.
   typedef std::mutex StrLockType;
   StrLockType StrLock;
   Ostream *StrDump; // Stream for dumping / diagnostics
   Ostream *StrEmit; // Stream for code emission
+  Ostream *StrError; // Stream for logging errors.
 
   ICE_CACHELINE_BOUNDARY;
 
   Intrinsics IntrinsicsInfo;
   const ClFlags &Flags;
   RandomNumberGenerator RNG; // TODO(stichnot): Move into Cfg.
   std::unique_ptr<ELFObjectWriter> ObjectWriter;
   BoundedProducerConsumerQueue<Cfg> OptQ;
   BoundedProducerConsumerQueue<EmitterWorkItem> EmitQ;
 
@@ skipping 74 matching lines @@
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H