Move some flag-like props from GlobalContext and TargetLowering to ClFlags.

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 128 matching lines @@
 
   public:
     ThreadContext() {}
     CodeStats StatsFunction;
     CodeStats StatsCumulative;
     TimerList Timers;
   };
 
 public:
   GlobalContext(Ostream *OsDump, Ostream *OsEmit, ELFStreamer *ELFStreamer,
-                VerboseMask Mask, TargetArch Arch, OptLevel Opt,
-                IceString TestPrefix, const ClFlags &Flags);
+                const ClFlags &Flags);
   ~GlobalContext();
 
-  VerboseMask getVerbose() const { return VMask; }
-
   // 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 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 &getStrEmit() { return *StrEmit; }
 
-  TargetArch getTargetArch() const { return Arch; }
-  OptLevel getOptLevel() const { return Opt; }
   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.
-  IceString getTestPrefix() const { return TestPrefix; }
   IceString mangleName(const IceString &Name) const;
 
   // Manage Constants.
   // getConstant*() functions are not const because they might add
   // something to the constant pool.
   Constant *getConstantInt(Type Ty, int64_t Value);
   Constant *getConstantInt1(int8_t ConstantInt1);
   Constant *getConstantInt8(int8_t ConstantInt8);
   Constant *getConstantInt16(int16_t ConstantInt16);
   Constant *getConstantInt32(int32_t ConstantInt32);
@@ skipping 220 matching lines @@
 
   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
 
   ICE_CACHELINE_BOUNDARY;
 
-  const VerboseMask VMask;
   Intrinsics IntrinsicsInfo;
-  const TargetArch Arch;
-  const OptLevel Opt;
-  const IceString TestPrefix;
   const ClFlags &Flags;
   RandomNumberGenerator RNG; // TODO(stichnot): Move into Cfg.
   std::unique_ptr<ELFObjectWriter> ObjectWriter;
   BoundedProducerConsumerQueue<Cfg> OptQ;
   BoundedProducerConsumerQueue<EmitterWorkItem> EmitQ;
 
   LockedPtr<ArenaAllocator<>> getAllocator() {
     return LockedPtr<ArenaAllocator<>>(&Allocator, &AllocLock);
   }
   LockedPtr<ConstantPool> getConstPool() {
@@ skipping 70 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