[CMAKE][llvm-libraries] Add Precompiled Headers option to improve build times

Author: ameerj

Diff for: llvm/CMakeLists.txt

@@ -1410,3 +1410,6 @@ endif()
 if (LLVM_INCLUDE_UTILS AND LLVM_INCLUDE_TOOLS)
   add_subdirectory(utils/llvm-locstats)
 endif()
+
+include(LLVMPrecompiledHeaders)
+llvm_lib_precompiled_headers()

Diff for: llvm/cmake/modules/HandleLLVMOptions.cmake

@@ -538,6 +538,8 @@ endif()
 
 option(LLVM_ENABLE_WARNINGS "Enable compiler warnings." ON)
 
+option(LLVM_ENABLE_PRECOMPILED_HEADERS "Enable precompiled headers to improve build times." ON)
+
 if( MSVC )
 
   # Add definitions that make MSVC much less annoying.
@@ -593,7 +595,11 @@ if( MSVC )
   # PDBs without changing codegen.
   option(LLVM_ENABLE_PDB OFF)
   if (LLVM_ENABLE_PDB AND uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
-    append("/Zi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+    if (LLVM_ENABLE_PRECOMPILED_HEADERS)
+        append("/Z7" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+    else()
+        append("/Zi" CMAKE_C_FLAGS CMAKE_CXX_FLAGS)
+    endif()
     # /DEBUG disables linker GC and ICF, but we want those in Release mode.
     append("/DEBUG /OPT:REF /OPT:ICF"
           CMAKE_EXE_LINKER_FLAGS CMAKE_MODULE_LINKER_FLAGS

Diff for: llvm/cmake/modules/LLVMPrecompiledHeaders.cmake

@@ -0,0 +1,35 @@
+macro(get_all_targets_recursive targets dir)
+    get_property(subdirectories DIRECTORY ${dir} PROPERTY SUBDIRECTORIES)
+    foreach(subdir ${subdirectories})
+        get_all_targets_recursive(${targets} ${subdir})
+    endforeach()
+
+    get_property(current_targets DIRECTORY ${dir} PROPERTY BUILDSYSTEM_TARGETS)
+    list(APPEND ${targets} ${current_targets})
+endmacro()
+
+function(get_all_targets dir outvar)
+    set(targets)
+    get_all_targets_recursive(targets ${dir})
+    set(${outvar} ${targets} PARENT_SCOPE)
+endfunction()
+
+function(add_llvm_lib_precompiled_headers target)
+    if (LLVM_ENABLE_PRECOMPILED_HEADERS)
+        get_target_property(target_type ${target} TYPE)
+        if (target_type STREQUAL "STATIC_LIBRARY")
+            target_precompile_headers(
+                ${target}
+                PRIVATE
+                "$<$<COMPILE_LANGUAGE:CXX>:${LLVM_MAIN_INCLUDE_DIR}/llvm/PrecompiledHeaders.h>"
+            )
+        endif()
+    endif()
+endfunction()
+
+function(llvm_lib_precompiled_headers)
+    get_all_targets("${LLVM_MAIN_SRC_DIR}/lib" lib_targets)
+    foreach(target ${lib_targets})
+        add_llvm_lib_precompiled_headers(${target})
+    endforeach()
+endfunction()

Diff for: llvm/include/llvm/Demangle/ItaniumDemangle.h

@@ -586,6 +586,12 @@ class EnableIfAttr : public Node {
 
 class ObjCProtoName : public Node {
   const Node *Ty;
+#if LLVM_ENABLE_PRECOMPILED_HEADERS
+public:
+  // When PCH is enabled, Protocol is unable to be read by the PointerType
+  // friend class, make it public to avoid this issue.
+  // TODO: Fix friend class interaction when PCH is enabled.
+#endif
   std::string_view Protocol;
 
   friend class PointerType;

Diff for: llvm/include/llvm/PrecompiledHeaders.h

@@ -0,0 +1,28 @@
+//===-- llvm/PrecompiledHeaders.h - Precompiled Headers ---------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the most common headers used within the LLVM library. 
+/// It is intended to be used as a precompiled header.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PRECOMPILEDHEADERS_H
+#define LLVM_PRECOMPILEDHEADERS_H
+
+#include "ADT/ArrayRef.h"
+
+#include "CodeGen/SelectionDAG.h"
+#include "CodeGen/TargetInstrInfo.h"
+
+#include "IR/IntrinsicInst.h"
+#include "IR/PassManager.h"
+
+#include "MC/MCContext.h"
+
+#endif // LLVM_PRECOMPILEDHEADERS_H

Diff for: llvm/lib/BinaryFormat/Dwarf.cpp

@@ -858,9 +858,9 @@ StringRef llvm::dwarf::RLEString(unsigned RLE) {
   }
 }
 
-constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[];
-constexpr char llvm::dwarf::EnumTraits<Form>::Type[];
-constexpr char llvm::dwarf::EnumTraits<Index>::Type[];
-constexpr char llvm::dwarf::EnumTraits<Tag>::Type[];
-constexpr char llvm::dwarf::EnumTraits<LineNumberOps>::Type[];
-constexpr char llvm::dwarf::EnumTraits<LocationAtom>::Type[];
+constexpr char llvm::dwarf::EnumTraits<llvm::dwarf::Attribute>::Type[];
+constexpr char llvm::dwarf::EnumTraits<llvm::dwarf::Form>::Type[];
+constexpr char llvm::dwarf::EnumTraits<llvm::dwarf::Index>::Type[];
+constexpr char llvm::dwarf::EnumTraits<llvm::dwarf::Tag>::Type[];
+constexpr char llvm::dwarf::EnumTraits<llvm::dwarf::LineNumberOps>::Type[];
+constexpr char llvm::dwarf::EnumTraits<llvm::dwarf::LocationAtom>::Type[];

Diff for: llvm/lib/BinaryFormat/MsgPackDocumentYAML.cpp

@@ -184,18 +184,18 @@ template <> struct TaggedScalarTraits<ScalarDocNode> {
 
   static QuotingType mustQuote(const ScalarDocNode &S, StringRef ScalarStr) {
     switch (S.getKind()) {
-    case Type::Int:
+    case msgpack::Type::Int:
       return ScalarTraits<int64_t>::mustQuote(ScalarStr);
-    case Type::UInt:
+    case msgpack::Type::UInt:
       return ScalarTraits<uint64_t>::mustQuote(ScalarStr);
-    case Type::Nil:
+    case msgpack::Type::Nil:
       return ScalarTraits<StringRef>::mustQuote(ScalarStr);
-    case Type::Boolean:
+    case msgpack::Type::Boolean:
       return ScalarTraits<bool>::mustQuote(ScalarStr);
-    case Type::Float:
+    case msgpack::Type::Float:
       return ScalarTraits<double>::mustQuote(ScalarStr);
-    case Type::Binary:
-    case Type::String:
+    case msgpack::Type::Binary:
+    case msgpack::Type::String:
       return ScalarTraits<std::string>::mustQuote(ScalarStr);
     default:
       llvm_unreachable("unrecognized ScalarKind");

Diff for: llvm/lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp

@@ -68,7 +68,7 @@ DWARFAbbreviationDeclaration::extract(DataExtractor Data, uint64_t *OffsetPtr) {
 
   // Read all of the abbreviation attributes and forms.
   while (Data.isValidOffset(*OffsetPtr)) {
-    auto A = static_cast<Attribute>(Data.getULEB128(OffsetPtr, &Err));
+    auto A = static_cast<dwarf::Attribute>(Data.getULEB128(OffsetPtr, &Err));
     if (Err)
       return std::move(Err);
 

Diff for: llvm/lib/Object/Minidump.cpp

@@ -92,7 +92,7 @@ Expected<ArrayRef<T>> MinidumpFile::getListStream(StreamType Type) const {
 
   return getDataSliceAs<T>(*Stream, ListOffset, ListSize);
 }
-template Expected<ArrayRef<Module>>
+template Expected<ArrayRef<minidump::Module>>
     MinidumpFile::getListStream(StreamType) const;
 template Expected<ArrayRef<Thread>>
     MinidumpFile::getListStream(StreamType) const;

Diff for: llvm/lib/ObjectYAML/MinidumpYAML.cpp

@@ -499,7 +499,7 @@ Stream::create(const Directory &StreamDesc, const object::MinidumpFile &File) {
     if (!ExpectedList)
       return ExpectedList.takeError();
     std::vector<ModuleListStream::entry_type> Modules;
-    for (const Module &M : *ExpectedList) {
+    for (const minidump::Module &M : *ExpectedList) {
       auto ExpectedName = File.getString(M.ModuleNameRVA);
       if (!ExpectedName)
         return ExpectedName.takeError();

Diff for: llvm/lib/Remarks/Remark.cpp

@@ -27,22 +27,24 @@ std::string Remark::getArgsAsMsg() const {
 }
 
 /// Returns the value of a specified key parsed from StringRef.
-std::optional<int> Argument::getValAsInt() const {
+std::optional<int> llvm::remarks::Argument::getValAsInt() const {
   APInt KeyVal;
   if (Val.getAsInteger(10, KeyVal))
     return std::nullopt;
   return KeyVal.getSExtValue();
 }
 
-bool Argument::isValInt() const { return getValAsInt().has_value(); }
+bool llvm::remarks::Argument::isValInt() const {
+  return getValAsInt().has_value();
+}
 
 void RemarkLocation::print(raw_ostream &OS) const {
   OS << "{ "
      << "File: " << SourceFilePath << ", Line: " << SourceLine
      << " Column:" << SourceColumn << " }\n";
 }
 
-void Argument::print(raw_ostream &OS) const {
+void llvm::remarks::Argument::print(raw_ostream &OS) const {
   OS << Key << ": " << Val << "\n";
 }
 
@@ -146,12 +148,12 @@ extern "C" uint32_t LLVMRemarkEntryGetNumArgs(LLVMRemarkEntryRef Remark) {
 
 extern "C" LLVMRemarkArgRef
 LLVMRemarkEntryGetFirstArg(LLVMRemarkEntryRef Remark) {
-  ArrayRef<Argument> Args = unwrap(Remark)->Args;
+  ArrayRef<remarks::Argument> Args = unwrap(Remark)->Args;
   // No arguments to iterate on.
   if (Args.empty())
     return nullptr;
   return reinterpret_cast<LLVMRemarkArgRef>(
-      const_cast<Argument *>(Args.begin()));
+      const_cast<remarks::Argument *>(Args.begin()));
 }
 
 extern "C" LLVMRemarkArgRef
@@ -160,10 +162,11 @@ LLVMRemarkEntryGetNextArg(LLVMRemarkArgRef ArgIt, LLVMRemarkEntryRef Remark) {
   if (ArgIt == nullptr)
     return nullptr;
 
-  auto It = (ArrayRef<Argument>::const_iterator)ArgIt;
+  auto It = (ArrayRef<remarks::Argument>::const_iterator)ArgIt;
   auto Next = std::next(It);
   if (Next == unwrap(Remark)->Args.end())
     return nullptr;
 
-  return reinterpret_cast<LLVMRemarkArgRef>(const_cast<Argument *>(Next));
+  return reinterpret_cast<LLVMRemarkArgRef>(
+      const_cast<remarks::Argument *>(Next));
 }

Diff for: llvm/lib/Remarks/YAMLRemarkParser.cpp

@@ -260,15 +260,16 @@ YAMLRemarkParser::parseRemark(yaml::Document &RemarkEntry) {
   }
 
   // Check if any of the mandatory fields are missing.
-  if (TheRemark.RemarkType == Type::Unknown || TheRemark.PassName.empty() ||
-      TheRemark.RemarkName.empty() || TheRemark.FunctionName.empty())
+  if (TheRemark.RemarkType == remarks::Type::Unknown ||
+      TheRemark.PassName.empty() || TheRemark.RemarkName.empty() ||
+      TheRemark.FunctionName.empty())
     return error("Type, Pass, Name or Function missing.",
                  *RemarkEntry.getRoot());
 
   return std::move(Result);
 }
 
-Expected<Type> YAMLRemarkParser::parseType(yaml::MappingNode &Node) {
+Expected<remarks::Type> YAMLRemarkParser::parseType(yaml::MappingNode &Node) {
   auto Type = StringSwitch<remarks::Type>(Node.getRawTag())
                   .Case("!Passed", remarks::Type::Passed)
                   .Case("!Missed", remarks::Type::Missed)
@@ -362,7 +363,7 @@ YAMLRemarkParser::parseDebugLoc(yaml::KeyValueNode &Node) {
   return RemarkLocation{*File, *Line, *Column};
 }
 
-Expected<Argument> YAMLRemarkParser::parseArg(yaml::Node &Node) {
+Expected<remarks::Argument> YAMLRemarkParser::parseArg(yaml::Node &Node) {
   auto *ArgMap = dyn_cast<yaml::MappingNode>(&Node);
   if (!ArgMap)
     return error("expected a value of mapping type.", Node);

Diff for: llvm/lib/Remarks/YAMLRemarkSerializer.cpp

@@ -25,7 +25,7 @@ template <typename T>
 static void mapRemarkHeader(yaml::IO &io, T PassName, T RemarkName,
                             std::optional<RemarkLocation> RL, T FunctionName,
                             std::optional<uint64_t> Hotness,
-                            ArrayRef<Argument> Args) {
+                            ArrayRef<remarks::Argument> Args) {
   io.mapRequired("Pass", PassName);
   io.mapRequired("Name", RemarkName);
   io.mapOptional("DebugLoc", RL);
@@ -41,19 +41,23 @@ template <> struct MappingTraits<remarks::Remark *> {
   static void mapping(IO &io, remarks::Remark *&Remark) {
     assert(io.outputting() && "input not yet implemented");
 
-    if (io.mapTag("!Passed", (Remark->RemarkType == Type::Passed)))
+    if (io.mapTag("!Passed", (Remark->RemarkType == remarks::Type::Passed)))
       ;
-    else if (io.mapTag("!Missed", (Remark->RemarkType == Type::Missed)))
+    else if (io.mapTag("!Missed",
+                       (Remark->RemarkType == remarks::Type::Missed)))
       ;
-    else if (io.mapTag("!Analysis", (Remark->RemarkType == Type::Analysis)))
+    else if (io.mapTag("!Analysis",
+                       (Remark->RemarkType == remarks::Type::Analysis)))
       ;
-    else if (io.mapTag("!AnalysisFPCommute",
-                       (Remark->RemarkType == Type::AnalysisFPCommute)))
+    else if (io.mapTag(
+                 "!AnalysisFPCommute",
+                 (Remark->RemarkType == remarks::Type::AnalysisFPCommute)))
       ;
     else if (io.mapTag("!AnalysisAliasing",
-                       (Remark->RemarkType == Type::AnalysisAliasing)))
+                       (Remark->RemarkType == remarks::Type::AnalysisAliasing)))
       ;
-    else if (io.mapTag("!Failure", (Remark->RemarkType == Type::Failure)))
+    else if (io.mapTag("!Failure",
+                       (Remark->RemarkType == remarks::Type::Failure)))
       ;
     else
       llvm_unreachable("Unknown remark type");
@@ -124,16 +128,16 @@ template <> struct BlockScalarTraits<StringBlockVal> {
 /// Keep this in this file so that it doesn't get misused from YAMLTraits.h.
 template <typename T> struct SequenceTraits<ArrayRef<T>> {
   static size_t size(IO &io, ArrayRef<T> &seq) { return seq.size(); }
-  static Argument &element(IO &io, ArrayRef<T> &seq, size_t index) {
+  static remarks::Argument &element(IO &io, ArrayRef<T> &seq, size_t index) {
     assert(io.outputting() && "input not yet implemented");
     // The assert above should make this "safer" to satisfy the YAMLTraits.
     return const_cast<T &>(seq[index]);
   }
 };
 
 /// Implement this as a mapping for now to get proper quotation for the value.
-template <> struct MappingTraits<Argument> {
-  static void mapping(IO &io, Argument &A) {
+template <> struct MappingTraits<remarks::Argument> {
+  static void mapping(IO &io, remarks::Argument &A) {
     assert(io.outputting() && "input not yet implemented");
 
     if (auto *Serializer = dyn_cast<YAMLStrTabRemarkSerializer>(
@@ -155,7 +159,7 @@ template <> struct MappingTraits<Argument> {
 } // end namespace yaml
 } // end namespace llvm
 
-LLVM_YAML_IS_SEQUENCE_VECTOR(Argument)
+LLVM_YAML_IS_SEQUENCE_VECTOR(remarks::Argument)
 
 YAMLRemarkSerializer::YAMLRemarkSerializer(raw_ostream &OS, SerializerMode Mode,
                                            std::optional<StringTable> StrTabIn)