[clang][codegen] Remember string used to create llvm::Regex for optimization remarks

[jansvoboda11]

Summary

Regular expression patterns passed through the command line are being used to create an instances of llvm::Regex and thrown away.

There is no API to serialize Regex back to the original pattern. This means we have no way to reconstruct the original pattern from command line. This is necessary for serializing CompilerInvocation.

This patch stores the original pattern string in CodeGenOptions alongside the llvm::Regex instance.

[dexonsmith]

LGTM! I also have a couple of optional suggestions to consider.

clang/include/clang/Basic/CodeGenOptions.h

286

This could also be:

explicit operator bool() const { return Regex != nullptr }

288–291

Another option would be:

llvm::Regex *operator->() const { return Regex.get(); }

treating RemarkPattern as a pointer wrapper (that also knows the std::string). WDYT?

[jansvoboda11]

Apply suggested change

[jansvoboda11]

I originally wanted to improve the API (make the null checks unnecessary), but keeping the API and minimizing the patch with your changes is nice too. I'm going with your suggestion, thanks!

clang/include/clang/Basic/CodeGenOptions.h

public:
 
   /// The format used for serializing remarks (default: YAML)
   std::string OptRecordFormat;
 
   /// The name of the partition that symbols are assigned to, specified with
   /// -fsymbol-partition (see https://lld.llvm.org/Partitions.html).
   std::string SymbolPartition;
 
+  /// Regular expression and the string it was created from.
+  struct RemarkPattern {
+    std::string Pattern;
+    std::shared_ptr<llvm::Regex> Regex;
+
+    explicit operator bool() const { return Regex != nullptr; }
+
+    llvm::Regex *operator->() const { return Regex.get(); }
+  };
+
   /// Regular expression to select optimizations for which we should enable
   /// optimization remarks. Transformation passes whose name matches this
   /// expression (and support this feature), will emit a diagnostic
   /// whenever they perform a transformation. This is enabled by the
   /// -Rpass=regexp flag.
-  std::shared_ptr<llvm::Regex> OptimizationRemarkPattern;
+  RemarkPattern OptimizationRemarkPattern;
 
   /// Regular expression to select optimizations for which we should enable
   /// missed optimization remarks. Transformation passes whose name matches this
   /// expression (and support this feature), will emit a diagnostic
   /// whenever they tried but failed to perform a transformation. This is
   /// enabled by the -Rpass-missed=regexp flag.
-  std::shared_ptr<llvm::Regex> OptimizationRemarkMissedPattern;
+  RemarkPattern OptimizationRemarkMissedPattern;
 
   /// Regular expression to select optimizations for which we should enable
   /// optimization analyses. Transformation passes whose name matches this
   /// expression (and support this feature), will emit a diagnostic
   /// whenever they want to explain why they decided to apply or not apply
   /// a given transformation. This is enabled by the -Rpass-analysis=regexp
   /// flag.
-  std::shared_ptr<llvm::Regex> OptimizationRemarkAnalysisPattern;
+  RemarkPattern OptimizationRemarkAnalysisPattern;
 
   /// Set of files defining the rules for the symbol rewriting.
   std::vector<std::string> RewriteMapFiles;
 
   /// Set of sanitizer checks that are non-fatal (i.e. execution should be
   /// continued when possible).
   SanitizerSet SanitizeRecover;
 

clang/lib/Frontend/CompilerInvocation.cpp

#undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 
   if (!AnOpts.ModelPath.empty() &&
       !llvm::sys::fs::is_directory(AnOpts.ModelPath))
     Diags->Report(diag::err_analyzer_config_invalid_input) << "model-path"
                                                            << "a filename";
 }
 
 /// Create a new Regex instance out of the string value in \p RpassArg.
-/// It returns a pointer to the newly generated Regex instance.
-static std::shared_ptr<llvm::Regex>
+/// It returns the string and a pointer to the newly generated Regex instance.
+static CodeGenOptions::RemarkPattern
 GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args,
                                 Arg *RpassArg) {
   StringRef Val = RpassArg->getValue();
   std::string RegexError;
   std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val);
   if (!Pattern->isValid(RegexError)) {
     Diags.Report(diag::err_drv_optimization_remark_pattern)
         << RegexError << RpassArg->getAsString(Args);
     Pattern.reset();
   }
-  return Pattern;
+  return {std::string(Val), Pattern};
 }
 
 static bool parseDiagnosticLevelMask(StringRef FlagName,
                                      const std::vector<std::string> &Levels,
                                      DiagnosticsEngine &Diags,
                                      DiagnosticLevelMask &M) {
   bool Success = true;
   for (const auto &Level : Levels) {