[Bridging PCH] Auto-generate and use temporary bridging PCHs from driver.

Author: graydon

include/swift/Driver/Action.h

@@ -48,9 +48,10 @@ class Action {
     REPLJob,
     LinkJob,
     GenerateDSYMJob,
+    GeneratePCHJob,
 
     JobFirst=CompileJob,
-    JobLast=GenerateDSYMJob
+    JobLast=GeneratePCHJob
   };
 
   static const char *getClassName(ActionClass AC);
@@ -268,6 +269,17 @@ class GenerateDSYMJobAction : public JobAction {
   }
 };
 
+class GeneratePCHJobAction : public JobAction {
+  virtual void anchor();
+public:
+  explicit GeneratePCHJobAction(Action *Input)
+    : JobAction(Action::GeneratePCHJob, Input, types::TY_PCH) {}
+
+  static bool classof(const Action *A) {
+    return A->getKind() == Action::GeneratePCHJob;
+  }
+};
+
 class LinkJobAction : public JobAction {
   virtual void anchor();
   LinkKind Kind;

include/swift/Driver/ToolChain.h

@@ -122,6 +122,9 @@ class ToolChain {
   constructInvocation(const GenerateDSYMJobAction &job,
                       const JobContext &context) const;
   virtual InvocationInfo
+  constructInvocation(const GeneratePCHJobAction &job,
+                      const JobContext &context) const;
+  virtual InvocationInfo
   constructInvocation(const AutolinkExtractJobAction &job,
                       const JobContext &context) const;
   virtual InvocationInfo

include/swift/Option/Options.td

@@ -237,6 +237,10 @@ def disable_swift_bridge_attr : Flag<["-"], "disable-swift-bridge-attr">,
   Flags<[FrontendOption, HelpHidden]>,
   HelpText<"Disable using the swift bridge attribute">;
 
+def disable_bridging_pch : Flag<["-"], "disable-bridging-pch">,
+  Flags<[HelpHidden]>,
+  HelpText<"Disable automatic generation of bridging PCH files">;
+
 // Diagnostic control options
 def suppress_warnings : Flag<["-"], "suppress-warnings">,
   Flags<[FrontendOption]>,

lib/Driver/Action.cpp

@@ -36,6 +36,7 @@ const char *Action::getClassName(ActionClass AC) {
     case REPLJob: return "repl";
     case LinkJob: return "link";
     case GenerateDSYMJob: return "generate-dSYM";
+    case GeneratePCHJob: return "generate-pch";
   }
 
   llvm_unreachable("invalid class");
@@ -62,3 +63,5 @@ void REPLJobAction::anchor() {}
 void LinkJobAction::anchor() {}
 
 void GenerateDSYMJobAction::anchor() {}
+
+void GeneratePCHJobAction::anchor() {}

lib/Driver/Compilation.cpp

@@ -115,7 +115,9 @@ static void populateInputInfoMap(InputInfoMap &inputs,
                                  const PerformJobsState &endState) {
   for (auto &entry : endState.UnfinishedCommands) {
     for (auto *action : entry.first->getSource().getInputs()) {
-      auto inputFile = cast<InputAction>(action);
+      auto inputFile = dyn_cast<InputAction>(action);
+      if (!inputFile)
+        continue;
 
       CompileJobAction::InputInfo info;
       info.previousModTime = entry.first->getInputModTime();
@@ -132,7 +134,9 @@ static void populateInputInfoMap(InputInfoMap &inputs,
       continue;
 
     for (auto *action : compileAction->getInputs()) {
-      auto inputFile = cast<InputAction>(action);
+      auto inputFile = dyn_cast<InputAction>(action);
+      if (!inputFile)
+        continue;
 
       CompileJobAction::InputInfo info;
       info.previousModTime = entry->getInputModTime();

lib/Driver/Driver.cpp

@@ -1271,6 +1271,24 @@ void Driver::buildActions(const ToolChain &TC,
   switch (OI.CompilerMode) {
   case OutputInfo::Mode::StandardCompile:
   case OutputInfo::Mode::UpdateCode: {
+
+    // If the user is importing a textual (.h) bridging header and we're in
+    // standard-compile (non-WMO) mode, we take the opportunity to precompile
+    // the header into a temporary PCH, and replace the import argument with the
+    // PCH in the subsequent frontend jobs.
+    JobAction *PCH = nullptr;
+    if (!Args.hasArg(options::OPT_disable_bridging_pch)) {
+      if (Arg *A = Args.getLastArg(options::OPT_import_objc_header)) {
+        StringRef Value = A->getValue();
+        auto Ty = TC.lookupTypeForExtension(llvm::sys::path::extension(Value));
+        if (Ty == types::TY_ObjCHeader) {
+          std::unique_ptr<Action> HeaderInput(new InputAction(*A, Ty));
+          PCH = new GeneratePCHJobAction(HeaderInput.release());
+          Actions.push_back(PCH);
+        }
+      }
+    }
+
     for (const InputPair &Input : Inputs) {
       types::ID InputType = Input.first;
       const Arg *InputArg = Input.second;
@@ -1302,6 +1320,21 @@ void Driver::buildActions(const ToolChain &TC,
                                              previousBuildState));
           AllModuleInputs.push_back(Current.get());
         }
+        if (PCH) {
+          // FIXME: When we have a PCH job, it's officially owned by the Actions
+          // array; but it's also a secondary input to each of the current
+          // JobActions, which means that we need to flip the "owns inputs" bit
+          // on the JobActions so they don't try to free it. That in turn means
+          // we need to transfer ownership of all the JobActions' existing
+          // inputs to the Actions array, since the JobActions either own or
+          // don't own _all_ of their inputs. Ownership can't vary
+          // input-by-input.
+          auto *job = cast<JobAction>(Current.get());
+          auto inputs = job->getInputs();
+          Actions.append(inputs.begin(), inputs.end());
+          job->setOwnsInputs(false);
+          job->addInput(PCH);
+        }
         AllLinkerInputs.push_back(Current.release());
         break;
       }
@@ -1555,6 +1588,12 @@ void Driver::buildJobs(const ActionList &Actions, const OutputInfo &OI,
     unsigned NumOutputs = 0;
     for (const Action *A : Actions) {
       types::ID Type = A->getType();
+
+      // Skip any GeneratePCHJobActions or InputActions incidentally stored in
+      // Actions (for ownership), as a result of PCH-generation.
+      if (isa<GeneratePCHJobAction>(A) || isa<InputAction>(A))
+        continue;
+
       // Only increment NumOutputs if this is an output which must have its
       // path specified using -o.
       // (Module outputs can be specified using -module-output-path, or will
@@ -1581,8 +1620,10 @@ void Driver::buildJobs(const ActionList &Actions, const OutputInfo &OI,
   }
 
   for (const Action *A : Actions) {
-    (void)buildJobsForAction(C, cast<JobAction>(A), OI, OFM, TC,
-                             /*TopLevel*/true, JobCache);
+    if (auto *JA = dyn_cast<JobAction>(A)) {
+      (void)buildJobsForAction(C, JA, OI, OFM, TC,
+                               /*TopLevel*/true, JobCache);
+    }
   }
 }
 
@@ -1641,6 +1682,13 @@ static StringRef getOutputFilename(Compilation &C,
     return Buffer.str();
   }
 
+  // FIXME: Treat GeneratePCHJobAction as non-top-level (to get tempfile and not
+  // use the -o arg) even though, based on ownership considerations within the
+  // driver, it is stored as a "top level" JobAction.
+  if (isa<GeneratePCHJobAction>(JA)) {
+    AtTopLevel = false;
+  }
+
   // We don't have an output from an Action-specific command line option,
   // so figure one out using the defaults.
   if (AtTopLevel) {
@@ -1661,8 +1709,8 @@ static StringRef getOutputFilename(Compilation &C,
 
   // We don't yet have a name, assign one.
   if (!AtTopLevel) {
-    // We should output to a temporary file, since we're not at
-    // the top level.
+    // We should output to a temporary file, since we're not at the top level
+    // (or are generating a bridging PCH, which is currently always a temp).
     StringRef Stem = llvm::sys::path::stem(BaseName);
     StringRef Suffix = types::getTypeTempSuffix(JA->getType());
     std::error_code EC =

lib/Driver/ToolChain.cpp

@@ -83,6 +83,7 @@ ToolChain::constructJob(const JobAction &JA,
     CASE(ModuleWrapJob)
     CASE(LinkJob)
     CASE(GenerateDSYMJob)
+    CASE(GeneratePCHJob)
     CASE(AutolinkExtractJob)
     CASE(REPLJob)
 #undef CASE

lib/Driver/ToolChains.cpp

@@ -133,7 +133,6 @@ static void addCommonFrontendArgs(const ToolChain &TC,
   inputArgs.AddLastArg(arguments, options::OPT_enable_app_extension);
   inputArgs.AddLastArg(arguments, options::OPT_enable_testing);
   inputArgs.AddLastArg(arguments, options::OPT_g_Group);
-  inputArgs.AddLastArg(arguments, options::OPT_import_objc_header);
   inputArgs.AddLastArg(arguments, options::OPT_import_underlying_module);
   inputArgs.AddLastArg(arguments, options::OPT_module_cache_path);
   inputArgs.AddLastArg(arguments, options::OPT_module_link_name);
@@ -258,9 +257,6 @@ ToolChain::constructInvocation(const CompileJobAction &job,
 
   Arguments.push_back(FrontendModeOption);
 
-  assert(context.Inputs.empty() &&
-         "The Swift frontend does not expect to be fed any input Jobs!");
-
   // Add input arguments.
   switch (context.OI.CompilerMode) {
   case OutputInfo::Mode::StandardCompile:
@@ -318,6 +314,23 @@ ToolChain::constructInvocation(const CompileJobAction &job,
   addCommonFrontendArgs(*this, context.OI, context.Output, context.Args,
                         Arguments);
 
+  // Pass along an -import-objc-header arg, replacing the argument with the name
+  // of any input PCH to the current action if one is present.
+  if (context.Args.hasArgNoClaim(options::OPT_import_objc_header)) {
+    bool ForwardAsIs = true;
+    for (auto *IJ : context.Inputs) {
+      if (!IJ->getOutput().getAnyOutputForType(types::TY_PCH).empty()) {
+        Arguments.push_back("-import-objc-header");
+        addInputsOfType(Arguments, context.Inputs, types::TY_PCH);
+        ForwardAsIs = false;
+        break;
+      }
+    }
+    if (ForwardAsIs) {
+      context.Args.AddLastArg(Arguments, options::OPT_import_objc_header);
+    }
+  }
+
   // Pass the optimization level down to the frontend.
   context.Args.AddLastArg(Arguments, options::OPT_O_Group);
 
@@ -426,6 +439,7 @@ ToolChain::constructInvocation(const InterpretJobAction &job,
 
   addCommonFrontendArgs(*this, context.OI, context.Output, context.Args,
                         Arguments);
+  context.Args.AddLastArg(Arguments, options::OPT_import_objc_header);
 
   // Pass the optimization level down to the frontend.
   context.Args.AddLastArg(Arguments, options::OPT_O_Group);
@@ -618,6 +632,7 @@ ToolChain::constructInvocation(const MergeModuleJobAction &job,
 
   addCommonFrontendArgs(*this, context.OI, context.Output, context.Args,
                         Arguments);
+  context.Args.AddLastArg(Arguments, options::OPT_import_objc_header);
 
   Arguments.push_back("-module-name");
   Arguments.push_back(context.Args.MakeArgString(context.OI.ModuleName));
@@ -687,6 +702,7 @@ ToolChain::constructInvocation(const REPLJobAction &job,
   ArgStringList FrontendArgs;
   addCommonFrontendArgs(*this, context.OI, context.Output, context.Args,
                         FrontendArgs);
+  context.Args.AddLastArg(FrontendArgs, options::OPT_import_objc_header);
   context.Args.AddAllArgs(FrontendArgs, options::OPT_l, options::OPT_framework,
                           options::OPT_L);
 
@@ -731,6 +747,30 @@ ToolChain::constructInvocation(const GenerateDSYMJobAction &job,
   return {"dsymutil", Arguments};
 }
 
+ToolChain::InvocationInfo
+ToolChain::constructInvocation(const GeneratePCHJobAction &job,
+                               const JobContext &context) const {
+  assert(context.Inputs.empty());
+  assert(context.InputActions.size() == 1);
+  assert(context.Output.getPrimaryOutputType() == types::TY_PCH);
+
+  ArgStringList Arguments;
+
+  Arguments.push_back("-frontend");
+
+  addCommonFrontendArgs(*this, context.OI, context.Output, context.Args,
+                        Arguments);
+
+  addInputsOfType(Arguments, context.InputActions, types::TY_ObjCHeader);
+
+  Arguments.push_back("-emit-pch");
+  Arguments.push_back("-o");
+  Arguments.push_back(
+    context.Args.MakeArgString(context.Output.getPrimaryOutputFilename()));
+
+  return {SWIFT_EXECUTABLE_NAME, Arguments};
+}
+
 ToolChain::InvocationInfo
 ToolChain::constructInvocation(const AutolinkExtractJobAction &job,
                                const JobContext &context) const {

test/ClangImporter/pch-bridging-header.swift

@@ -1,7 +1,24 @@
-// RUN: rm -rf %t && mkdir -p %t
+// REQUIRES: objc_interop
+// RUN: rm -rf %t && mkdir -p %t/tmp
+
+// First test the explicit frontend-based bridging PCH generation and use works
 // RUN: %target-swift-frontend -emit-pch -o %t/sdk-bridging-header.pch %S/Inputs/sdk-bridging-header.h
 // RUN: %target-swift-frontend -parse -verify %s -import-objc-header %t/sdk-bridging-header.pch
-// REQUIRES: objc_interop
+
+// Now test the driver-automated version is inert when disabled
+// RUN: env TMPDIR=%t/tmp/ %target-swiftc_driver -disable-bridging-pch -parse -save-temps %s -import-objc-header %S/Inputs/sdk-bridging-header.h
+// RUN: not ls %t/tmp/*.pch >/dev/null 2>&1
+
+// Test the driver-automated version works when not-disabled
+// RUN: env TMPDIR=%t/tmp/ %target-swiftc_driver -parse -save-temps %s -import-objc-header %S/Inputs/sdk-bridging-header.h
+// RUN: ls %t/tmp/*.pch >/dev/null 2>&1
+// RUN: llvm-objdump -raw-clang-ast %t/tmp/*.pch | llvm-bcanalyzer -dump | %FileCheck %s
+// CHECK: ORIGINAL_FILE{{.*}}Inputs/sdk-bridging-header.h
+
+// Test the driver-automated version deletes its PCH file when done
+// RUN: rm %t/tmp/*.pch
+// RUN: env TMPDIR=%t/tmp/ %target-swiftc_driver -parse %s -import-objc-header %S/Inputs/sdk-bridging-header.h
+// RUN: not ls %t/tmp/*.pch >/dev/null 2>&1
 
 import Foundation
 

test/Driver/Inputs/bridging-header.h

@@ -0,0 +1 @@
+extern int x;