reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/Support/CommandLine.h

  322       return SC == &*AllSubCommands;
 1860 StringMap<Option *> &getRegisteredOptions(SubCommand &Sub = *TopLevelSubCommand);
 1980                           SubCommand &Sub = *TopLevelSubCommand);
 1990                           SubCommand &Sub = *TopLevelSubCommand);

include/llvm/Support/ManagedStatic.h

   94   C *operator->() { return &**this; }

lib/Bitcode/Reader/BitcodeReader.cpp

 6271   return *ErrorCategory;

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 8876     sys::SmartScopedLock<true> Lock(*VTMutex);

lib/DebugInfo/CodeView/CodeViewError.cpp

   46   return *CodeViewErrCategory;

lib/DebugInfo/MSF/MSFError.cpp

   45 const std::error_category &llvm::msf::MSFErrCategory() { return *MSFCategory; }

lib/DebugInfo/PDB/GenericError.cpp

   46 const std::error_category &llvm::pdb::PDBErrCategory() { return *PDBCategory; }

lib/DebugInfo/PDB/Native/RawError.cpp

   51 const std::error_category &llvm::pdb::RawErrCategory() { return *RawCategory; }

lib/ExecutionEngine/GDBRegistrationListener.cpp

  138   std::lock_guard<llvm::sys::Mutex> locked(*JITDebugLock);
  162   std::lock_guard<llvm::sys::Mutex> locked(*JITDebugLock);
  181   std::lock_guard<llvm::sys::Mutex> locked(*JITDebugLock);
  230   return &*GDBRegListener;

lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp

  110   sys::ScopedLock Writer(*FunctionsLock);
  111   ExFunc FnPtr = (*FuncNames)[ExtName];
  113     FnPtr = (*FuncNames)[("lle_X_" + F->getName()).str()];
  261   std::unique_lock<sys::Mutex> Guard(*FunctionsLock);
  497   sys::ScopedLock Writer(*FunctionsLock);
  498   (*FuncNames)["lle_X_atexit"]       = lle_X_atexit;
  499   (*FuncNames)["lle_X_exit"]         = lle_X_exit;
  500   (*FuncNames)["lle_X_abort"]        = lle_X_abort;
  502   (*FuncNames)["lle_X_printf"]       = lle_X_printf;
  503   (*FuncNames)["lle_X_sprintf"]      = lle_X_sprintf;
  504   (*FuncNames)["lle_X_sscanf"]       = lle_X_sscanf;
  505   (*FuncNames)["lle_X_scanf"]        = lle_X_scanf;
  506   (*FuncNames)["lle_X_fprintf"]      = lle_X_fprintf;
  507   (*FuncNames)["lle_X_memset"]       = lle_X_memset;
  508   (*FuncNames)["lle_X_memcpy"]       = lle_X_memcpy;

lib/ExecutionEngine/JITLink/JITLink.cpp

   56   return std::error_code(GenericJITLinkError, *JITLinkerErrorCategory);

lib/ExecutionEngine/Orc/OrcError.cpp

   78   return std::error_code(static_cast<UT>(ErrCode), *OrcErrCat);
  103                          *OrcErrCat);

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

   65   return std::error_code(GenericRTDyldError, *RTDyldErrorCategory);

lib/IR/Core.cpp

   82 LLVMContextRef LLVMGetGlobalContext() { return wrap(&*GlobalContext); }
  231   return wrap(new Module(ModuleID, *GlobalContext));

lib/IR/LLVMContextImpl.cpp

  245     OPG = &(*OptBisector);

lib/IR/PassRegistry.cpp

   32   return &*PassRegistryObj;

lib/IR/PassTimingInfo.cpp

  111   TheTimeInfo = &*TTI;
  133   sys::SmartScopedLock<true> Lock(*TimingInfoMutex);

lib/Object/Error.cpp

   77   return *error_category;

lib/ProfileData/Coverage/CoverageMapping.cpp

  832   return *ErrorCategory;

lib/ProfileData/InstrProf.cpp

  138   return *ErrorCategory;

lib/ProfileData/SampleProf.cpp

   87   return *ErrorCategory;

lib/Support/CommandLine.cpp

  154     registerSubCommand(&*TopLevelSubCommand);
  155     registerSubCommand(&*AllSubCommands);
  175     if (SC == &*AllSubCommands) {
  186       addLiteralOption(Opt, &*TopLevelSubCommand, Name);
  231     if (SC == &*AllSubCommands) {
  247       addOption(O, &*TopLevelSubCommand);
  289       removeOption(O, &*TopLevelSubCommand);
  328       updateArgStr(O, NewName, &*TopLevelSubCommand);
  363     if (sub != &*AllSubCommands) {
  398     registerSubCommand(&*TopLevelSubCommand);
  399     registerSubCommand(&*AllSubCommands);
  513   assert(&Sub != &*AllSubCommands);
  545     return &*TopLevelSubCommand;
  547     if (S == &*AllSubCommands)
  555   return &*TopLevelSubCommand;
 1289   SubCommand *ChosenSubCommand = &*TopLevelSubCommand;
 1294     if (ChosenSubCommand != &*TopLevelSubCommand)
 2105     if (Sub == &*TopLevelSubCommand) {
 2129     if (Sub == &*TopLevelSubCommand && !Subs.empty()) {
 2291     cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 2297           cl::sub(*AllSubCommands));
 2305         cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 2313          cl::cat(GenericCategory), cl::sub(*AllSubCommands));
 2319     cl::sub(*AllSubCommands));
 2324     cl::init(false), cl::cat(GenericCategory), cl::sub(*AllSubCommands));

lib/Support/CrashRecoveryContext.cpp

  119   std::lock_guard<std::mutex> L(*gCrashRecoveryContextMutex);
  128   std::lock_guard<std::mutex> L(*gCrashRecoveryContextMutex);

lib/Support/Debug.cpp

   55   for (auto &d : *CurrentDebugType) {

lib/Support/DebugCounter.cpp

   64 DebugCounter &DebugCounter::instance() { return *DC; }

lib/Support/DynamicLibrary.cpp

  144   SmartScopedLock<true> Lock(*SymbolsMutex);
  145   (*ExplicitSymbols)[SymbolName] = SymbolValue;
  152   HandleSet& HS = *OpenedHandles;
  156     SmartScopedLock<true> Lock(*SymbolsMutex);
  165   SmartScopedLock<true> Lock(*SymbolsMutex);
  181     SmartScopedLock<true> Lock(*SymbolsMutex);

lib/Support/Error.cpp

   74                          *ErrorErrorCat);
   79                          *ErrorErrorCat);
   84                          *ErrorErrorCat);

lib/Support/Options.cpp

   32 OptionRegistry &OptionRegistry::instance() { return *OR; }

lib/Support/PluginLoader.cpp

   26   sys::SmartScopedLock<true> Lock(*PluginsLock);
   37   sys::SmartScopedLock<true> Lock(*PluginsLock);
   42   sys::SmartScopedLock<true> Lock(*PluginsLock);
   45   return (*Plugins)[num];

lib/Support/Statistic.cpp

  101     sys::SmartMutex<true> &Lock = *StatLock;
  102     StatisticInfo &SI = *StatInfo;
  149   sys::SmartScopedLock<true> Writer(*StatLock);
  171   StatisticInfo &Stats = *StatInfo;
  201   sys::SmartScopedLock<true> Reader(*StatLock);
  202   StatisticInfo &Stats = *StatInfo;
  228   sys::SmartScopedLock<true> Reader(*StatLock);
  229   StatisticInfo &Stats = *StatInfo;
  255   sys::SmartScopedLock<true> Reader(*StatLock);

lib/Support/Timer.cpp

   38   return *LibSupportInfoOutputFilename;
   88 static TimerGroup *getDefaultTimerGroup() { return &*DefaultTimerGroup; }
  199     sys::SmartScopedLock<true> L(*TimerLock);
  236   sys::SmartScopedLock<true> L(*TimerLock);
  260   sys::SmartScopedLock<true> L(*TimerLock);
  268   sys::SmartScopedLock<true> L(*TimerLock);
  291   sys::SmartScopedLock<true> L(*TimerLock);
  371     sys::SmartScopedLock<true> L(*TimerLock);
  381   sys::SmartScopedLock<true> L(*TimerLock);
  387   sys::SmartScopedLock<true> L(*TimerLock);
  394   sys::SmartScopedLock<true> L(*TimerLock);
  411   sys::SmartScopedLock<true> L(*TimerLock);
  434   sys::SmartScopedLock<true> L(*TimerLock);
  441   (void)*NamedGroupedTimers;

lib/Support/Unix/Process.inc

  335   std::lock_guard<std::mutex> G(*TermColorMutex);

lib/Support/Unix/Signals.inc

  133     sys::SmartScopedLock<true> Writer(*Lock);
  285   sys::SmartScopedLock<true> Guard(*SignalHandlerRegistrationMutex);
  411   *FilesToRemoveCleanup;

lib/Target/NVPTX/NVPTXUtilities.cpp

   96   if ((*annotationCache).find(m) != (*annotationCache).end())
   96   if ((*annotationCache).find(m) != (*annotationCache).end())
   97     (*annotationCache)[m][gv] = std::move(tmp);
  101     (*annotationCache)[m] = std::move(tmp1);
  109   if ((*annotationCache).find(m) == (*annotationCache).end())
  109   if ((*annotationCache).find(m) == (*annotationCache).end())
  111   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
  111   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
  113   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
  113   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
  115   retval = (*annotationCache)[m][gv][prop][0];
  123   if ((*annotationCache).find(m) == (*annotationCache).end())
  123   if ((*annotationCache).find(m) == (*annotationCache).end())
  125   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
  125   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
  127   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
  127   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
  129   retval = (*annotationCache)[m][gv][prop];

lib/Transforms/IPO/PassManagerBuilder.cpp

  209     for (auto &Ext : *GlobalExtensions) {

tools/clang/lib/ASTMatchers/ASTMatchersInternal.cpp

  194   return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance);

tools/clang/lib/ASTMatchers/Dynamic/Parser.cpp

  596     : Tokenizer(Tokenizer), S(S ? S : &*DefaultRegistrySema),

tools/clang/lib/CrossTU/CrossTranslationUnit.cpp

  128   return std::error_code(static_cast<int>(Code), *Category);

tools/clang/lib/Frontend/PrecompiledPreamble.cpp

  772   return std::error_code(static_cast<int>(Error), *BuildPreambleErrCategory);

tools/clang/lib/Frontend/SerializedDiagnosticReader.cpp

  370   return *ErrorCategory;

tools/clang/lib/Tooling/CommonOptionsParser.cpp

   89                                         cl::sub(*cl::AllSubCommands));
   93       cl::cat(Category), cl::sub(*cl::AllSubCommands));
   98       cl::cat(Category), cl::sub(*cl::AllSubCommands));
  103       cl::cat(Category), cl::sub(*cl::AllSubCommands));

tools/clang/tools/clang-refactor/ClangRefactor.cpp

   42                              cl::sub(*cl::AllSubCommands));
   46                              cl::sub(*cl::AllSubCommands));

tools/clang/tools/libclang/CIndex.cpp

 3287   (void)*RegisterFatalErrorHandlerOnce;
 8975   std::lock_guard<std::mutex> L(*LoggingMutex);

tools/llc/llc.cpp

  565       for (const std::string &RunPassName : *RunPassNames) {

tools/lldb/source/Host/posix/HostInfoPosix.cpp

  113   return *g_user_id_resolver;

tools/lldb/source/Utility/Log.cpp

  244   for (auto &entry : *g_channel_map)
  260   for (const auto &channel : *g_channel_map)
  271   for (const auto &channel : *g_channel_map)
  353   for (auto &c: *g_channel_map)

tools/lldb/source/Utility/UserIDResolver.cpp

   44 UserIDResolver &UserIDResolver::GetNoopResolver() { return *g_noop_resolver; }

tools/llvm-xray/llvm-xray.cpp

   34       if (SC == &*cl::TopLevelSubCommand) {

tools/llvm-xray/xray-registry.cpp

   29   (*Commands)[SC] = Command;

unittests/Support/CommandLineTest.cpp

   90       cl::getRegisteredOptions(*cl::TopLevelSubCommand);
  393       cl::getRegisteredOptions(*cl::TopLevelSubCommand);
  418       cl::getRegisteredOptions(*cl::TopLevelSubCommand);
  492   StackOption<bool> AllOpt("everywhere", cl::sub(*cl::AllSubCommands),
  529   StackOption<bool> TopLevelOpt("top-level", cl::sub(*cl::TopLevelSubCommand),
  578       "top-level-remove", cl::sub(*cl::TopLevelSubCommand), cl::init(false));
  580       "top-level-keep", cl::sub(*cl::TopLevelSubCommand), cl::init(false));
  601   StackOption<bool> RemoveOption("remove-option", cl::sub(*cl::AllSubCommands),
  603   StackOption<bool> KeepOption("keep-option", cl::sub(*cl::AllSubCommands),
  682   StackOption<std::string> Bar("bar", cl::sub(*cl::AllSubCommands),
  687   StackOption<bool> Foo("foo", cl::init(false), cl::sub(*cl::AllSubCommands),
  982   for (auto &OM : cl::getRegisteredOptions(*cl::TopLevelSubCommand)) {

unittests/Support/ErrorTest.cpp

  954 const std::error_category &TErrorCategory() { return *TestErrCategory; }

unittests/Support/ManagedStatic.cpp

   27     *ms;
   64     ++(*Ms1);
   69     ++(*Ms1);
   78   *Ms2;
   97   EXPECT_EQ(42, *Custom);