cleanup doxygen for IceClFlags.h

src/IceClFlags.h

 //===- subzero/src/IceClFlags.h - Cl Flags for translation ------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Declares command line flags controlling translation.
+/// \brief Declares class Ice::ClFlags .

[Jim Stichnoth, 2015/12/17 20:31:07]

This comment doesn't seem particularly useful, on the order of something like:

  i++; // increment i

The previous comment seemed more useful.

But I'm not familiar enough with common doxygen usage, maybe this is how it's
normally done?

I guess there is information that the class declares *only* ClFlags.

Also, the original phrase "controlling translation" is basically moved down to
the class definition, so that's good.

It would be nice to retain the "command line" phrase, since the variables are
set on the command line.

[rkotlerimgtec, 2015/12/17 22:03:47]

The idea is that file may contain the definition of many classes and so this is
just explaining what the file is about. Usually people are looking at the class
so that is where the more detailed information about what the class does would
be.

I'm not fixed on this way I did it, but that is my reasoning.

 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICECLFLAGS_H
 #define SUBZERO_SRC_ICECLFLAGS_H
 
 #include "IceDefs.h"
 #include "IceTypes.h"
 
 namespace Ice {
 
 class ClFlagsExtra;
 
+/// Define variables which configure translation and related support functions.
 class ClFlags {
   ClFlags(const ClFlags &) = delete;
   ClFlags &operator=(const ClFlags &) = delete;
 
 public:
+  /// User defined constructor.

[Jim Stichnoth, 2015/12/17 20:31:07]

What does "user defined" mean in this context?

[rkotlerimgtec, 2015/12/17 22:03:48]

It means it's not the default one the language supplies.
That is the c++ technical term so if someone sees a reference
to the constructor in other parts of the code, they will know it's not
the predefined one, since that one would have the same signature.

   ClFlags() { resetClFlags(*this); }
 
+  /// \brief Parse commmand line options for Subzero

[Jim Stichnoth, 2015/12/17 20:31:07]

I would be happier if all these \brief descriptions ended with a period.

[rkotlerimgtec, 2015/12/17 22:03:47]

Done.

+  ///
+  /// This is done use cl::ParseCommandLineOptions and the static variables of type

[Jim Stichnoth, 2015/12/17 20:31:07]

s/use/using/ ?

Maybe say cl::ParseCommandLineOptions() to make it clear that it is a function
call?

Also, 80-col.

[rkotlerimgtec, 2015/12/17 22:03:48]

Done.

+  /// cl::opt defined in IceClFlags.cpp

[Jim Stichnoth, 2015/12/17 20:31:07]

Is there a way to markup IceClFlags.cpp so that a link to that file's
documentation is automatically inserted?

[rkotlerimgtec, 2015/12/17 22:03:48]

I tried another variant here. Doxygen has lots of features.
There could well be something more clear that I could do here.

   static void parseFlags(int argc, char *argv[]);
+  /// Reset all configuration options to their nominal values.
   static void resetClFlags(ClFlags &OutFlags);
+  /// \brief Retrieve the configuration option state
+  ///
+  /// This is defined by static variables of type llvm::cl::opt defined in
+  /// IceClFlags.cpp
   static void getParsedClFlags(ClFlags &OutFlags);
+  /// Retrieve the extra configuration options state.
   static void getParsedClFlagsExtra(ClFlagsExtra &OutFlagsExtra);
 
   // bool accessors.
 
+  /// Get the value of ClFlags::AllowErrorRecovery
   bool getAllowErrorRecovery() const { return AllowErrorRecovery; }
+  /// Set ClFlags::AllowErrorRecovery to a new value
   void setAllowErrorRecovery(bool NewValue) { AllowErrorRecovery = NewValue; }
 
+  /// Get the value of ClFlags::AllowExternDefinedSymbols
   bool getAllowExternDefinedSymbols() const {
     return AllowExternDefinedSymbols;
   }
+  /// Set ClFlags::AllowExternDefinedSymbols to a new value
   void setAllowExternDefinedSymbols(bool NewValue) {
     AllowExternDefinedSymbols = NewValue;
   }
 
+  /// Get the value of ClFlags::AllowIacaMarks
   bool getAllowIacaMarks() const { return AllowIacaMarks; }
+  /// Set ClFlags::AllowIacaMarks to a new value
   void setAllowIacaMarks(bool NewValue) { AllowIacaMarks = NewValue; }
 
+  /// Get the value of ClFlags::AllowUninitializedGlobals
   bool getAllowUninitializedGlobals() const {
     return AllowUninitializedGlobals;
   }
+  /// Set ClFlags::AllowUninitializedGlobals to a new value
   void setAllowUninitializedGlobals(bool NewValue) {
     AllowUninitializedGlobals = NewValue;
   }
 
+  /// Get the value of ClFlags::DataSections
   bool getDataSections() const { return DataSections; }
+  /// Set ClFlags::DataSections to a new value
   void setDataSections(bool NewValue) { DataSections = NewValue; }
 
+  /// Get the value of ClFlags::DecorateAsm
   bool getDecorateAsm() const { return DecorateAsm; }
+  /// Set ClFlags::DecorateAsm to a new value
   void setDecorateAsm(bool NewValue) { DecorateAsm = NewValue; }
 
+  /// Get the value of ClFlags::DisableHybridAssembly
   bool getDisableHybridAssembly() const { return DisableHybridAssembly; }
+  /// Set ClFlags::DisableHybridAssembly to a new value
   void setDisableHybridAssembly(bool NewValue) {
     DisableHybridAssembly = NewValue;
   }
 
+  /// Get the value of ClFlags::DisableInternal
   bool getDisableInternal() const { return DisableInternal; }
+  /// Set ClFlags::DisableInternal to a new value
   void setDisableInternal(bool NewValue) { DisableInternal = NewValue; }
 
+  /// Get the value of ClFlags::DisableTranslation
   bool getDisableTranslation() const { return DisableTranslation; }
+  /// Set ClFlags::DisableTranslation to a new value
   void setDisableTranslation(bool NewValue) { DisableTranslation = NewValue; }
 
+  /// Get the value of ClFlags::DumpStats
   bool getDumpStats() const { return BuildDefs::dump() && DumpStats; }
+  /// Set ClFlags::DumpStats to a new value
   void setDumpStats(bool NewValue) { DumpStats = NewValue; }
 
+  /// Get the value of ClFlags::EnableBlockProfile
   bool getEnableBlockProfile() const { return EnableBlockProfile; }
+  /// Set ClFlags::EnableBlockProfile to a new value
   void setEnableBlockProfile(bool NewValue) { EnableBlockProfile = NewValue; }
 
+  /// Get the value of ClFlags::ForceMemIntrinOpt
   bool getForceMemIntrinOpt() const { return ForceMemIntrinOpt; }
+  /// Set ClFlags::ForceMemIntrinOpt to a new value
   void setForceMemIntrinOpt(bool NewValue) { ForceMemIntrinOpt = NewValue; }
 
+  /// Get the value of ClFlags::FunctionSections
   bool getFunctionSections() const { return FunctionSections; }
+  /// Set ClFlags::FunctionSections to a new value
   void setFunctionSections(bool NewValue) { FunctionSections = NewValue; }
 
+  /// \brief Get the value of ClFlags::GenerateUnitTestMessages
+  ///
+  /// Note: If dump routines have been turned off, the error messages
+  /// will not be readable. Hence, turn off.
   bool getGenerateUnitTestMessages() const {
-    // Note: If dump routines have been turned off, the error messages will not
-    // be readable. Hence, turn off.
     return !BuildDefs::dump() || GenerateUnitTestMessages;
   }
+  /// Set ClFlags::GenerateUnitTestMessages to a new value
   void setGenerateUnitTestMessages(bool NewValue) {
     GenerateUnitTestMessages = NewValue;
   }
 
+  /// Get the value of ClFlags::MockBoundsCheck
   bool getMockBoundsCheck() const { return MockBoundsCheck; }
+  /// Set ClFlags::MockBoundsCheck to a new value
   void setMockBoundsCheck(bool NewValue) { MockBoundsCheck = NewValue; }
 
+  /// Get the value of ClFlags::PhiEdgeSplit
   bool getPhiEdgeSplit() const { return PhiEdgeSplit; }
+  /// Set ClFlags::PhiEdgeSplit to a new value
   void setPhiEdgeSplit(bool NewValue) { PhiEdgeSplit = NewValue; }
 
+  /// Get the value of ClFlags::RandomNopInsertion
   bool shouldDoNopInsertion() const { return RandomNopInsertion; }
+  /// Set ClFlags::RandomNopInsertion to a new value
   void setShouldDoNopInsertion(bool NewValue) { RandomNopInsertion = NewValue; }
 
+  /// Get the value of ClFlags::RandomRegAlloc
   bool shouldRandomizeRegAlloc() const { return RandomRegAlloc; }
+  /// Set ClFlags::RandomRegAlloc to a new value
   void setShouldRandomizeRegAlloc(bool NewValue) { RandomRegAlloc = NewValue; }
 
+  /// Get the value of ClFlags::RepeatRegAlloc
   bool shouldRepeatRegAlloc() const { return RepeatRegAlloc; }
+  /// Set ClFlags::RepeatRegAlloc to a new value
   void setShouldRepeatRegAlloc(bool NewValue) { RepeatRegAlloc = NewValue; }
 
+  /// Get the value of ClFlags::SkipUnimplemented
   bool getSkipUnimplemented() const { return SkipUnimplemented; }
+  /// Set ClFlags::SkipUnimplemented to a new value
   void setSkipUnimplemented(bool NewValue) { SkipUnimplemented = NewValue; }
 
+  /// Get the value of ClFlags::SubzeroTimingEnabled
   bool getSubzeroTimingEnabled() const { return SubzeroTimingEnabled; }
+  /// Set ClFlags::SubzeroTimingEnableds to a new value
   void setSubzeroTimingEnabled(bool NewValue) {
     SubzeroTimingEnabled = NewValue;
   }
 
+  /// Get the value of ClFlags::TimeEachFunction
   bool getTimeEachFunction() const {
     return BuildDefs::dump() && TimeEachFunction;
   }
+  /// Set ClFlags::TimeEachFunction to a new value
   void setTimeEachFunction(bool NewValue) { TimeEachFunction = NewValue; }
 
+  /// Get the value of ClFlags::UseSandboxing
   bool getUseSandboxing() const { return UseSandboxing; }
+  /// Set ClFlags::UseSandboxing to a new value
   void setUseSandboxing(bool NewValue) { UseSandboxing = NewValue; }
 
   // Enum and integer accessors.
+  /// Get the value of ClFlags::Opt
   OptLevel getOptLevel() const { return Opt; }
+  /// Set ClFlags::Opt to a new value
   void setOptLevel(OptLevel NewValue) { Opt = NewValue; }
 
+  /// Get the value of ClFlags::OutFileType
   FileType getOutFileType() const { return OutFileType; }
+  /// Set ClFlags::OutFileType to a new value
   void setOutFileType(FileType NewValue) { OutFileType = NewValue; }
 
+  /// Get the value of ClFlags::RandomMaxNopsPerInstruction
   int getMaxNopsPerInstruction() const { return RandomMaxNopsPerInstruction; }
+  /// Set ClFlags::RandomMaxNopsPerInstruction to a new value
   void setMaxNopsPerInstruction(int NewValue) {
     RandomMaxNopsPerInstruction = NewValue;
   }
 
+  /// Get the value of ClFlags::RandomNopProbabilityAsPercentage
   int getNopProbabilityAsPercentage() const {
     return RandomNopProbabilityAsPercentage;
   }
+  /// Set ClFlags::RandomNopProbabilityAsPercentage to a new value
   void setNopProbabilityAsPercentage(int NewValue) {
     RandomNopProbabilityAsPercentage = NewValue;
   }
 
+  /// Get the value of ClFlags::TArch
   TargetArch getTargetArch() const { return TArch; }
+  /// Set ClFlags::TArch to a new value
   void setTargetArch(TargetArch NewValue) { TArch = NewValue; }
 
+  /// Get the value of ClFlags::TInstrSet
   TargetInstructionSet getTargetInstructionSet() const { return TInstrSet; }
+  /// Set ClFlags::TInstrSet to a new value
   void setTargetInstructionSet(TargetInstructionSet NewValue) {
     TInstrSet = NewValue;
   }
+
+  /// \brief Get the value of ClFlags::TestStackExtra
+  ///
+  /// Always 0 if BuildDefs::minimal()
   uint32_t getTestStackExtra() const {
     return BuildDefs::minimal() ? 0 : TestStackExtra;
   }
+  /// \brief Set ClFlags::TestStackExtra to a new value
+  ///
+  /// Always 0 if BuildDefs::minimal()
   void setTestStackExtra(uint32_t NewValue) {
     if (BuildDefs::minimal())
       return;
     TestStackExtra = NewValue;
   }
 
+  /// \brief Get the value of ClFlags::VMask
+  ///
+  /// None if BuildDefs::dump()
   VerboseMask getVerbose() const {
     return BuildDefs::dump() ? VMask : (VerboseMask)IceV_None;
   }
+  /// \brief Set ClFlags::VMask to a new value
+  ///
+  /// None if BuildDefs::dump()
   void setVerbose(VerboseMask NewValue) { VMask = NewValue; }
 
+  /// Set ClFlags::RandomizeAndPoolImmediatesOption to a new value
   void
   setRandomizeAndPoolImmediatesOption(RandomizeAndPoolImmediatesEnum Option) {
     RandomizeAndPoolImmediatesOption = Option;
   }
+  /// Get the value of ClFlags::RandomizeAndPoolImmediatesOption
   RandomizeAndPoolImmediatesEnum getRandomizeAndPoolImmediatesOption() const {
     return RandomizeAndPoolImmediatesOption;
   }
 
+  /// Set ClFlags::RandomizeAndPoolImmediatesThreshold to a new value
   void setRandomizeAndPoolImmediatesThreshold(uint32_t Threshold) {
     RandomizeAndPoolImmediatesThreshold = Threshold;
   }
+  /// Get the value of ClFlags::RandomizeAndPoolImmediatesThreshold
   uint32_t getRandomizeAndPoolImmediatesThreshold() const {
     return RandomizeAndPoolImmediatesThreshold;
   }
 
+  /// Get the value of ClFlags::ReorderBasicBlocks
   bool shouldReorderBasicBlocks() const { return ReorderBasicBlocks; }
+  /// Set ClFlags::ReorderBasicBlocks to a new value
   void setShouldReorderBasicBlocks(bool NewValue) {
     ReorderBasicBlocks = NewValue;
   }
 
+  /// Set ClFlags::ReorderFunctions to a new value
   void setShouldReorderFunctions(bool Option) { ReorderFunctions = Option; }
+  /// Get the value of ClFlags::ReorderFunctions
   bool shouldReorderFunctions() const { return ReorderFunctions; }
 
+  /// Set ClFlags::ReorderFunctionsWindowSize to a new value
   void setReorderFunctionsWindowSize(uint32_t Size) {
     ReorderFunctionsWindowSize = Size;
   }
+  /// Get the value of ClFlags::ReorderFunctionsWindowSize
   uint32_t getReorderFunctionsWindowSize() const {
     return ReorderFunctionsWindowSize;
   }
 
+  /// Set ClFlags::ReorderGlobalVariables to a new value
   void setShouldReorderGlobalVariables(bool Option) {
     ReorderGlobalVariables = Option;
   }
+  /// Get the value of ClFlags::ReorderGlobalVariables
   bool shouldReorderGlobalVariables() const { return ReorderGlobalVariables; }
 
+  /// Set ClFlags::ReorderPooledConstants to a new value
   void setShouldReorderPooledConstants(bool Option) {
     ReorderPooledConstants = Option;
   }
+  /// Get the value of ClFlags::ReorderPooledConstants
   bool shouldReorderPooledConstants() const { return ReorderPooledConstants; }
 
   // IceString accessors.
 
+  /// Get the value of ClFlags::DefaultFunctionPrefix
   const IceString &getDefaultFunctionPrefix() const {
     return DefaultFunctionPrefix;
   }
+  /// Set ClFlags::DefaultFunctionPrefix to a new value
   void setDefaultFunctionPrefix(const IceString &NewValue) {
     DefaultFunctionPrefix = NewValue;
   }
 
+  /// Get the value of ClFlags::DefaultGlobalPrefix
   const IceString &getDefaultGlobalPrefix() const {
     return DefaultGlobalPrefix;
   }
+  /// Set ClFlags::DefaultGlobalPrefix to a new value
   void setDefaultGlobalPrefix(const IceString &NewValue) {
     DefaultGlobalPrefix = NewValue;
   }
 
+  /// Get the value of ClFlags::TestPrefix
   const IceString &getTestPrefix() const { return TestPrefix; }
+  /// Set ClFlags::TestPrefix to a new value
   void setTestPrefix(const IceString &NewValue) { TestPrefix = NewValue; }
 
+  /// Get the value of ClFlags::TimingFocusOn
   const IceString &getTimingFocusOn() const { return TimingFocusOn; }
+  /// Set ClFlags::TimingFocusOn to a new value
   void setTimingFocusOn(const IceString &NewValue) { TimingFocusOn = NewValue; }
 
+  /// Get the value of ClFlags::TranslateOnly
   const IceString &getTranslateOnly() const { return TranslateOnly; }
+  /// Set ClFlags::TranslateOnly to a new value
   void setTranslateOnly(const IceString &NewValue) { TranslateOnly = NewValue; }
 
+  /// Get the value of ClFlags::VerboseFocusOn
   const IceString &getVerboseFocusOn() const { return VerboseFocusOn; }
+  /// Set ClFlags::VerboseFocusOns to a new value
   void setVerboseFocusOn(const IceString &NewValue) {
     VerboseFocusOn = NewValue;
   }
 
   // size_t and 64-bit accessors.
 
+  /// Get the value of ClFlags::NumTranslationThreads
   size_t getNumTranslationThreads() const { return NumTranslationThreads; }
   bool isSequential() const { return NumTranslationThreads == 0; }
+  /// Set ClFlags::NumTranslationThreads to a new value
   void setNumTranslationThreads(size_t NewValue) {
     NumTranslationThreads = NewValue;
   }
 
+  /// Get the value of ClFlags::RandomSeed
   uint64_t getRandomSeed() const { return RandomSeed; }
+  /// Set ClFlags::RandomSeed to a new value
   void setRandomSeed(size_t NewValue) { RandomSeed = NewValue; }
 
 private:
+  /// see anonymous_namespace{IceClFlags.cpp}::AllowErrorRecovery
   bool AllowErrorRecovery;
+  /// see anonymous_namespace{IceClFlags.cpp}::AllowExternDefinedSymbols
   bool AllowExternDefinedSymbols;
+  /// see anonymous_namespace{IceClFlags.cpp}::AllowIacaMarks
   bool AllowIacaMarks;
+  /// see anonymous_namespace{IceClFlags.cpp}::AllowUninitializedGlobals
   bool AllowUninitializedGlobals;
+  /// see anonymous_namespace{IceClFlags.cpp}::DataSections
   bool DataSections;
+  /// see anonymous_namespace{IceClFlags.cpp}::DecorateAsm
   bool DecorateAsm;
+  /// see anonymous_namespace{IceClFlags.cpp}::DisableHybridAssembly
   bool DisableHybridAssembly;
+  /// see anonymous_namespace{IceClFlags.cpp}::DisableInternal
   bool DisableInternal;
+  /// see anonymous_namespace{IceClFlags.cpp}::DisableTranslation
   bool DisableTranslation;
+  /// see anonymous_namespace{IceClFlags.cpp}::DumpStats
   bool DumpStats;
+  /// see anonymous_namespace{IceClFlags.cpp}::EnableBlockProfile
   bool EnableBlockProfile;
+  /// see anonymous_namespace{IceClFlags.cpp}::ForceMemIntrinOpt
   bool ForceMemIntrinOpt;
+  /// see anonymous_namespace{IceClFlags.cpp}::FunctionSections
   bool FunctionSections;
+  /// Always false.

[Jim Stichnoth, 2015/12/17 20:31:07]

I don't think so:

unittest/BitcodeMunge.cpp:  Flags.setGenerateUnitTestMessages(true);

[rkotlerimgtec, 2015/12/17 22:03:47]

Done.

   bool GenerateUnitTestMessages;
+  /// see anonymous_namespace{IceClFlags.cpp}::MockBoundsCheck
   bool MockBoundsCheck;
+  /// see anonymous_namespace{IceClFlags.cpp}::EnablePhiEdgeSplit
   bool PhiEdgeSplit;
+  /// see anonymous_namespace{IceClFlags.cpp}::ShouldDoNopInsertion
   bool RandomNopInsertion;
+  /// see anonymous_namespace{IceClFlags.cpp}::RandomizeRegisterAllocation
   bool RandomRegAlloc;
+  /// see anonymous_namespace{IceClFlags.cpp}::RepeatRegAlloc
   bool RepeatRegAlloc;
+  /// see anonymous_namespace{IceClFlags.cpp}::ReorderBasicBlocks
   bool ReorderBasicBlocks;
+  /// see anonymous_namespace{IceClFlags.cpp}::ReorderFunctions
   bool ReorderFunctions;
+  /// see anonymous_namespace{IceClFlags.cpp}::ReorderGlobalVariables
   bool ReorderGlobalVariables;
+  /// see anonymous_namespace{IceClFlags.cpp}::ReorderPooledConstants
   bool ReorderPooledConstants;
+  /// see anonymous_namespace{IceClFlags.cpp}::SkipUnimplemented
   bool SkipUnimplemented;
+  /// see anonymous_namespace{IceClFlags.cpp}::SubzeroTimingEnabled
   bool SubzeroTimingEnabled;
+  /// see anonymous_namespace{IceClFlags.cpp}::TimeEachFunction
   bool TimeEachFunction;
+  /// see anonymous_namespace{IceClFlags.cpp}::UseSandboxing
   bool UseSandboxing;
-
+  /// see anonymous_namespace{IceClFlags.cpp}::OLevel
   OptLevel Opt;
+  /// see anonymous_namespace{IceClFlags.cpp}::OutFileType
   FileType OutFileType;
+  /// see anonymous_namespace{IceClFlags.cpp}::RandomizeAndPoolImmediatesOption
   RandomizeAndPoolImmediatesEnum RandomizeAndPoolImmediatesOption;
+  /// see anonymous_namespace{IceClFlags.cpp}::RandomizeAndPoolImmediatesThreshold

[Jim Stichnoth, 2015/12/17 20:31:07]

80-col

[rkotlerimgtec, 2015/12/17 22:03:47]

Done.

   uint32_t RandomizeAndPoolImmediatesThreshold;
+  /// Always 0

[Jim Stichnoth, 2015/12/17 20:31:07]

I think pnacl-sz -max-nops-per-instruction=123 changes this.

[rkotlerimgtec, 2015/12/17 22:03:48]

Done.

   int RandomMaxNopsPerInstruction;
+  /// Always 0

[Jim Stichnoth, 2015/12/17 20:31:07]

Same as above, I think there's another command-line option to control it.

[rkotlerimgtec, 2015/12/17 22:03:48]

Done.

   int RandomNopProbabilityAsPercentage;
+  /// see anonymous_namespace{IceClFlags.cpp}::ReorderFunctionsWindowSize
   uint32_t ReorderFunctionsWindowSize;
+  /// see anonymous_namespace{IceClFlags.cpp}::TargetArch
   TargetArch TArch;
+  /// see anonymous_namespace{IceClFlags.cpp}::TestStackExtra
   uint32_t TestStackExtra;
+  /// see anonymous_namespace{IceClFlags.cpp}::TargetInstructionSet
   TargetInstructionSet TInstrSet;
+  /// see anonymous_namespace{IceClFlags.cpp}::VerboseList
   VerboseMask VMask;
-
+  /// see anonymous_namespace{IceClFlags.cpp}::DefaultFunctionPrefix
   IceString DefaultFunctionPrefix;
+  /// see anonymous_namespace{IceClFlags.cpp}::DefaultGlobalPrefix
   IceString DefaultGlobalPrefix;
+  /// see anonymous_namespace{IceClFlags.cpp}::TestPrefix
   IceString TestPrefix;
+  /// see anonymous_namespace{IceClFlags.cpp}::TimingFocusOn
   IceString TimingFocusOn;
+  /// see anonymous_namespace{IceClFlags.cpp}::TranslateOnly
   IceString TranslateOnly;
+  /// see anonymous_namespace{IceClFlags.cpp}::VerboseFocusOn
   IceString VerboseFocusOn;
+  /// see anonymous_namespace{IceClFlags.cpp}::NumThreads
 
   size_t NumTranslationThreads; // 0 means completely sequential
+  /// see anonymous_namespace{IceClFlags.cpp}::RandomSeed
   uint64_t RandomSeed;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECLFLAGS_H