[ExternalGenericMetadataBuilder] Add configurable log levels.

Add a call to set the log level of the builder, and have the builder default to no logs except for fatal errors.

Author: mikeash

lib/ExternalGenericMetadataBuilder/ExternalGenericMetadataBuilder.cpp

@@ -42,15 +42,16 @@ namespace swift {
 // conditional eventually. LOG_ENABLED can be used to gate work that's needed
 // for log statements but not for anything else.
 enum class LogLevel {
-  Detail,
-  Info,
-  Warning,
+  None = 0,
+  Warning = 1,
+  Info = 2,
+  Detail = 3,
 };
-static const LogLevel logLevel = LogLevel::Warning;
+
 #pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
 #define LOG(level, fmt, ...)                                                   \
   do {                                                                         \
-    if (level >= logLevel)                                                     \
+    if (level <= getLogLevel())                                                \
       fprintf(stderr, "%s:%d:%s: " fmt "\n", METADATA_BUILDER_LOG_FILE_NAME,   \
               __LINE__, __func__, __VA_ARGS__);                                \
   } while (0)
@@ -649,6 +650,14 @@ class ExternalGenericMetadataBuilderContext {
   ExternalGenericMetadataBuilderContext &
   operator=(const ExternalGenericMetadataBuilderContext &) = delete;
 
+  LogLevel getLogLevel() {
+    return logLevel;
+  }
+
+  void setLogLevel(int level) {
+    logLevel = LogLevel(level);
+  }
+
   template <typename T>
   WritableData<T> allocate(size_t size) {
     auto atom = allocateAtom(size);
@@ -703,6 +712,7 @@ class ExternalGenericMetadataBuilderContext {
   void populateMachOFixups(MachOFile *file);
 
   void readMachOSections(MachOFile *file);
+  BuilderErrorOr<std::string> _mangledNominalTypeNameForBoundGenericNode(Demangle::NodePointer BoundGenericNode);
   BuilderErrorOr<std::optional<typename Builder::ConstructedMetadata>>
   constructMetadataForMangledTypeName(llvm::StringRef typeName);
   BuilderErrorOr<std::optional<typename Builder::ConstructedMetadata>>
@@ -720,6 +730,9 @@ class ExternalGenericMetadataBuilderContext {
   void writeJSONSerialization(llvm::json::OStream &J, unsigned platform,
                               const std::string &platformVersion);
 
+  // The current log level.
+  LogLevel logLevel = LogLevel::None;
+
   // The architecture being targeted.
   std::string arch;
 
@@ -825,6 +838,10 @@ class ReaderWriter {
     ReaderWriter &readerWriter;
     Demangle::Demangler &dem;
 
+    LogLevel getLogLevel() {
+      return readerWriter.getLogLevel();
+    }
+
   public:
     ResolveToDemangling(ReaderWriter &readerWriter, Demangle::Demangler &dem)
         : readerWriter(readerWriter), dem(dem) {}
@@ -893,11 +910,18 @@ class ReaderWriter {
   ReaderWriter(ExternalGenericMetadataBuilderContext<Runtime> *context)
       : context(context) {}
 
-  bool isLoggingEnabled() { return true; }
+  bool isLoggingEnabled() { return getLogLevel() >= LogLevel::Info; }
+
+  LogLevel getLogLevel() {
+    return context->getLogLevel();
+  }
 
   SWIFT_FORMAT(5, 6)
   void log(const char *filename, unsigned line, const char *function,
            const char *fmt, ...) {
+    if (!isLoggingEnabled())
+      return;
+
     va_list args;
     va_start(args, fmt);
 
@@ -1826,19 +1850,7 @@ void ExternalGenericMetadataBuilderContext<Runtime>::readMachOSections(
 }
 
 template <typename Runtime>
-BuilderErrorOr<std::optional<typename ExternalGenericMetadataBuilderContext<
-    Runtime>::Builder::ConstructedMetadata>>
-ExternalGenericMetadataBuilderContext<
-    Runtime>::constructMetadataForMangledTypeName(llvm::StringRef typeName) {
-  auto node = demangleCtx.demangleTypeAsNode(typeName);
-  if (!node) {
-    return BuilderError("Failed to demangle '%s'.", typeName.str().c_str());
-  }
-  LOG(LogLevel::Detail, "Result: %s", nodeToString(node).c_str());
-  return constructMetadataForNode(node);
-}
-
-static BuilderErrorOr<std::string> _mangledNominalTypeNameForBoundGenericNode(
+BuilderErrorOr<std::string> ExternalGenericMetadataBuilderContext<Runtime>::_mangledNominalTypeNameForBoundGenericNode(
     Demangle::NodePointer BoundGenericNode) {
   LOG(LogLevel::Detail, "BoundGenericNode:\n%s",
       getNodeTreeAsString(BoundGenericNode).c_str());
@@ -1868,6 +1880,19 @@ static BuilderErrorOr<std::string> _mangledNominalTypeNameForBoundGenericNode(
   return mangling.result();
 }
 
+template <typename Runtime>
+BuilderErrorOr<std::optional<typename ExternalGenericMetadataBuilderContext<
+    Runtime>::Builder::ConstructedMetadata>>
+ExternalGenericMetadataBuilderContext<
+    Runtime>::constructMetadataForMangledTypeName(llvm::StringRef typeName) {
+  auto node = demangleCtx.demangleTypeAsNode(typeName);
+  if (!node) {
+    return BuilderError("Failed to demangle '%s'.", typeName.str().c_str());
+  }
+  LOG(LogLevel::Detail, "Result: %s", nodeToString(node).c_str());
+  return constructMetadataForNode(node);
+}
+
 // Returns the constructed metadata, or no value if the node doesn't contain a
 // bound generic.
 template <typename Runtime>
@@ -2343,6 +2368,11 @@ void swift_externalMetadataBuilder_destroy(
   delete builder;
 }
 
+void swift_externalMetadataBuilder_setLogLevel(
+    struct SwiftExternalMetadataBuilder *builder, int level) {
+  builder->withContext([&](auto *context) { context->setLogLevel(level); });
+}
+
 const char *swift_externalMetadataBuilder_readNamesJSON(
     struct SwiftExternalMetadataBuilder *builder, const char *names_json) {
   auto names = swift::readNames(names_json);

lib/ExternalGenericMetadataBuilder/ExternalGenericMetadataBuilder.h

@@ -54,6 +54,15 @@ SWIFT_ATTRIBUTE_FOR_EXPORTS
 const char *swift_externalMetadataBuilder_readNamesJSON(
     struct SwiftExternalMetadataBuilder *, const char *names_json);
 
+// Set the log level of the library. Accepted values are:
+// 0 - Only fatal errors.
+// 1 - Warnings.
+// 2 - Informational messages.
+// 3 - Detailed informational messages.
+SWIFT_ATTRIBUTE_FOR_EXPORTS
+void swift_externalMetadataBuilder_setLogLevel(
+    struct SwiftExternalMetadataBuilder *, int level);
+
 // Returns an error string if the dylib could not be added. The builder owns the
 // string, so the caller does not have to free it. The string remains valid
 // until at least the next call to the builder.