tool.cpp File Reference

Go to the source code of this file.

Functions
std::mutex &	outputRegistryMutex ()
std::unordered_set< std::string > &	outputRegistry ()
bool	registerOutputPath (const std::string &path)
void	unregisterOutputPath (const std::string &path)
int	main (int argc, const char **argv)

Variables
constexpr unsigned	kMacroFlagNone = 0U
constexpr unsigned	kMacroFlagExpansion = 1U
constexpr unsigned	kMacroFlagInvocation = 2U

Function Documentation

main()

int main	(	int	argc,
		const char **	argv )

Definition at line 705 of file tool.cpp.

                                      {
  // Initialize LLVM infrastructure (this triggers command-line option registration!)
  llvm::InitLLVM InitLLVM(argc, argv);
 
  // Parse command-line options
  cl::ParseCommandLineOptions(argc, argv, "ascii-chat instrumentation tool\n");
 
  const fs::path outputDir = fs::path(OutputDirectoryOption.getValue());
  fs::path inputRoot;
  if (!InputRootOption.getValue().empty()) {
    inputRoot = fs::path(InputRootOption.getValue());
  } else {
    inputRoot = fs::current_path();
  }
 
  std::vector<std::string> rawSourceArgs;
  rawSourceArgs.reserve(SourcePaths.size());
  for (const auto &path : SourcePaths) {
    rawSourceArgs.push_back(path);
  }
  std::vector<std::string> sourcePaths;
  std::vector<std::string> extraCompilerArgs;
  for (std::size_t i = 0; i < rawSourceArgs.size(); ++i) {
    const std::string &entry = rawSourceArgs[i];
    if (entry.empty()) {
      continue;
    }
    if (entry == "--") {
      continue;
    }
    if (entry[0] == '-') {
      extraCompilerArgs.push_back(entry);
      const bool consumesNext = (entry == "-I" || entry == "-isystem" || entry == "-include" ||
                                 entry == "-include-pch" || entry == "-imacros" || entry == "-idirafter" ||
                                 entry == "-iprefix" || entry == "-iwithprefix" || entry == "-iwithprefixbefore" ||
                                 entry == "-resource-dir" || entry == "-Xclang" || entry == "-Xpreprocessor");
      if (consumesNext && (i + 1) < rawSourceArgs.size()) {
        extraCompilerArgs.push_back(rawSourceArgs[i + 1]);
        ++i;
      }
      continue;
    }
    sourcePaths.push_back(entry);
  }
  if (!FileListOption.getValue().empty()) {
    std::ifstream listStream(FileListOption.getValue());
    if (!listStream.is_open()) {
      llvm::errs() << "Failed to open file list: " << FileListOption.getValue() << "\n";
      return 1;
    }
 
    std::string line;
    while (std::getline(listStream, line)) {
      llvm::StringRef trimmed(line);
      trimmed = trimmed.trim();
      if (trimmed.empty()) {
        continue;
      }
      sourcePaths.emplace_back(trimmed.str());
    }
  }
 
  if (sourcePaths.empty()) {
    llvm::errs()
        << "No translation units specified for instrumentation. Provide positional source paths or --file-list."
        << "\n";
    return 1;
  }
 
  if (fs::exists(outputDir)) {
    if (!fs::is_directory(outputDir)) {
      llvm::errs() << "Output path exists and is not a directory: " << outputDir.c_str() << "\n";
      return 1;
    }
  } else {
    std::error_code errorCode;
    fs::create_directories(outputDir, errorCode);
    if (errorCode) {
      llvm::errs() << "Failed to create output directory: " << outputDir.c_str() << " - " << errorCode.message()
                   << "\n";
      return 1;
    }
  }
 
  const bool logMacroExpansions = LogMacroExpansionsOption.getValue() || LegacyIncludeMacroExpansionsOption.getValue();
  const bool logMacroInvocations = LogMacroInvocationsOption.getValue();
 
  if (!LogMacroExpansionsOption.getValue() && LegacyIncludeMacroExpansionsOption.getValue()) {
    llvm::errs() << "warning: --include-macro-expansions is deprecated; use --log-macro-expansions instead\n";
  }
 
  // Load compilation database
  std::string buildPath = BuildPath.getValue();
  if (buildPath.empty()) {
    buildPath = ".";
  }
  std::string errorMessage;
  std::unique_ptr<tooling::CompilationDatabase> compilations =
      tooling::CompilationDatabase::loadFromDirectory(buildPath, errorMessage);
  if (!compilations) {
    llvm::errs() << "Error loading compilation database from '" << buildPath << "': " << errorMessage << "\n";
    return 1;
  }
 
  std::unique_ptr<MappedCompilationDatabase> mapped;
  if (!CompileSourceOption.empty()) {
    if (sourcePaths.size() != 1) {
      llvm::errs() << "--compile-source requires exactly one input\n";
      return 1;
    }
    mapped = std::make_unique<MappedCompilationDatabase>(*compilations, CompileSourceOption.getValue());
  }
  clang::tooling::ClangTool tool(mapped ? static_cast<const tooling::CompilationDatabase &>(*mapped) : *compilations,
                                 sourcePaths);
 
  if (!ResourceDirOption.empty()) {
    const std::string resourceDir = ResourceDirOption.getValue();
    tool.appendArgumentsAdjuster([resourceDir](const tooling::CommandLineArguments &args, StringRef) {
      auto adjusted = args;
      adjusted.push_back("-resource-dir");
      adjusted.push_back(resourceDir);
      return adjusted;
    });
  }
  if (mapped) {
    tool.appendArgumentsAdjuster([](const tooling::CommandLineArguments &args, StringRef input) {
      auto adjusted = args;
      adjusted.push_back("-DDEFER_PARSING=1");
      adjusted.push_back("-iquote");
      adjusted.push_back(fs::path(input.str()).parent_path().string());
      return adjusted;
    });
  }
 
  if (!extraCompilerArgs.empty()) {
    const std::vector<std::string> extraArgsCopy(extraCompilerArgs.begin(), extraCompilerArgs.end());
    tool.appendArgumentsAdjuster([extraArgsCopy](const clang::tooling::CommandLineArguments &args, llvm::StringRef) {
      clang::tooling::CommandLineArguments adjusted = args;
      adjusted.insert(adjusted.end(), extraArgsCopy.begin(), extraArgsCopy.end());
      return adjusted;
    });
  }
 
  auto stripPchAdjuster = [](const clang::tooling::CommandLineArguments &args, llvm::StringRef) {
    clang::tooling::CommandLineArguments result;
    const auto containsCMakePch = [](llvm::StringRef value) { return value.contains("cmake_pch"); };
 
    for (std::size_t i = 0; i < args.size(); ++i) {
      const std::string &arg = args[i];
      llvm::StringRef argRef(arg);
 
      if ((argRef == "-include" || argRef == "--include" || argRef == "-include-pch" || argRef == "--include-pch") &&
          (i + 1) < args.size()) {
        if (containsCMakePch(args[i + 1])) {
          ++i;
          continue;
        }
      }
 
      if ((argRef.starts_with("-include=") || argRef.starts_with("--include=") || argRef.starts_with("-include-pch=") ||
           argRef.starts_with("--include-pch=")) &&
          containsCMakePch(argRef)) {
        continue;
      }
 
      result.push_back(arg);
    }
 
    return result;
  };
  tool.appendArgumentsAdjuster(stripPchAdjuster);
 
  auto ensureSourceIncludeAdjuster = [&inputRoot](const clang::tooling::CommandLineArguments &args, llvm::StringRef) {
    clang::tooling::CommandLineArguments result = args;
 
    const auto hasInclude = [&result](const std::string &dir) {
      const std::string combined = "-I" + dir;
      if (std::find(result.begin(), result.end(), combined) != result.end()) {
        return true;
      }
      for (std::size_t i = 0; i + 1 < result.size(); ++i) {
        if (result[i] == "-I" && result[i + 1] == dir) {
          return true;
        }
      }
      return false;
    };
 
    const auto appendInclude = [&result](const std::string &dir) {
      result.push_back("-I");
      result.push_back(dir);
    };
 
    const std::string libDir = (inputRoot / "lib").generic_string();
    const std::string srcDir = (inputRoot / "src").generic_string();
 
    if (!hasInclude(libDir)) {
      appendInclude(libDir);
    }
    if (!hasInclude(srcDir)) {
      appendInclude(srcDir);
    }
 
    return result;
  };
  tool.appendArgumentsAdjuster(ensureSourceIncludeAdjuster);
 
  // Instrumented headers are now hard-linked into the output tree, so we can
  // rely on the original include paths without further adjustment.
 
  // NOTE: -skip-function-bodies optimization removed - it was causing errors with LibTooling
  // LibTooling handles arguments differently than the clang driver, so -Xclang flags don't work
  // The optimization wasn't providing significant benefit anyway
 
  // Optimization: strip unnecessary compilation flags
  auto stripUnnecessaryFlags = [](const clang::tooling::CommandLineArguments &args, llvm::StringRef) {
    clang::tooling::CommandLineArguments result;
 
    for (size_t i = 0; i < args.size(); ++i) {
      const std::string &arg = args[i];
 
      // Skip sanitizer flags (not needed for instrumentation, slow down parsing)
      if (arg.find("-fsanitize") != std::string::npos)
        continue;
      if (arg.find("-fno-sanitize") != std::string::npos)
        continue;
      if (arg.find("sanitize") != std::string::npos)
        continue;
 
      // Skip debug info generation flags (not needed, slow down codegen)
      if (arg == "-g" || arg == "-g2" || arg == "-g3")
        continue;
      if (arg == "-gcolumn-info")
        continue;
      if (arg == "-fstandalone-debug")
        continue;
      if (arg.find("-gcodeview") != std::string::npos)
        continue;
      if (arg.find("-gdwarf") != std::string::npos)
        continue;
 
      // Skip stack protector (not needed for instrumentation)
      if (arg.find("-fstack-protector") != std::string::npos)
        continue;
 
      // Skip frame pointer flags
      if (arg.find("-fno-omit-frame-pointer") != std::string::npos)
        continue;
      if (arg.find("-fomit-frame-pointer") != std::string::npos)
        continue;
 
      // Skip optimization-related debug flags
      if (arg == "-fno-inline")
        continue;
      if (arg == "-fno-eliminate-unused-debug-types")
        continue;
 
      result.push_back(arg);
    }
 
    // NOTE: -w flag removed - it was causing "no such file or directory" errors with LibTooling
    // Warnings are already suppressed by the stripped flags above
 
    return result;
  };
  tool.appendArgumentsAdjuster(stripUnnecessaryFlags);
 
  InstrumentationActionFactory actionFactory(outputDir, inputRoot, !FileIncludeFilters.empty(),
                                             !FunctionIncludeFilters.empty(), logMacroInvocations, logMacroExpansions);
  const int executionResult = tool.run(&actionFactory);
  if (executionResult != 0) {
    llvm::errs() << "Instrumenter failed with code " << executionResult << "\n";
  }
  return executionResult;
}

References args.

outputRegistry()

std::unordered_set< std::string > & outputRegistry

(

)

Definition at line 40 of file tool.cpp.

                                              {
  static std::unordered_set<std::string> registry;
  return registry;
}

Referenced by registerOutputPath(), and unregisterOutputPath().

outputRegistryMutex()

std::mutex & outputRegistryMutex

(

)

Definition at line 35 of file tool.cpp.

                                {
  static std::mutex mutex;
  return mutex;
}

Referenced by registerOutputPath(), and unregisterOutputPath().

registerOutputPath()

bool registerOutputPath

(

const std::string &

path

)

Definition at line 45 of file tool.cpp.

                                               {
  std::lock_guard<std::mutex> guard(outputRegistryMutex());
  auto &registry = outputRegistry();
  auto [_, inserted] = registry.insert(path);
  return inserted;
}

References outputRegistry(), and outputRegistryMutex().

unregisterOutputPath()

void unregisterOutputPath

(

const std::string &

path

)

Definition at line 52 of file tool.cpp.

                                                 {
  std::lock_guard<std::mutex> guard(outputRegistryMutex());
  outputRegistry().erase(path);
}

References outputRegistry(), and outputRegistryMutex().

Variable Documentation

kMacroFlagExpansion

unsigned kMacroFlagExpansion = 1U

constexpr

Definition at line 115 of file tool.cpp.

kMacroFlagInvocation

unsigned kMacroFlagInvocation = 2U

constexpr

Definition at line 116 of file tool.cpp.

kMacroFlagNone

unsigned kMacroFlagNone = 0U

constexpr

Definition at line 114 of file tool.cpp.