private List <FileItem> SetupOutputFiles(UEToolChain ToolChain, CppCompileEnvironment BinaryCompileEnvironment, LinkEnvironment BinaryLinkEnvironment, ActionGraph ActionGraph) { // // Regular linking action. // List <FileItem> OutputFiles = new List <FileItem>(); if (bCreateImportLibrarySeparately) { // Mark the link environment as cross-referenced. BinaryLinkEnvironment.bIsCrossReferenced = true; if (BinaryLinkEnvironment.Platform != CppPlatform.Mac && BinaryLinkEnvironment.Platform != CppPlatform.Linux) { // Create the import library. OutputFiles.AddRange(ToolChain.LinkAllFiles(BinaryLinkEnvironment, true, ActionGraph)); } } BinaryLinkEnvironment.bIncludeDependentLibrariesInLibrary = bIncludeDependentLibrariesInLibrary; // Link the binary. FileItem[] Executables = ToolChain.LinkAllFiles(BinaryLinkEnvironment, false, ActionGraph); OutputFiles.AddRange(Executables); // Produce additional console app if requested if (Config.bBuildAdditionalConsoleApp) { // Produce additional binary but link it as a console app LinkEnvironment ConsoleAppLinkEvironment = new LinkEnvironment(BinaryLinkEnvironment); ConsoleAppLinkEvironment.bIsBuildingConsoleApplication = true; ConsoleAppLinkEvironment.WindowsEntryPointOverride = "WinMainCRTStartup"; // For WinMain() instead of "main()" for Launch module ConsoleAppLinkEvironment.OutputFilePaths = ConsoleAppLinkEvironment.OutputFilePaths.Select(Path => GetAdditionalConsoleAppPath(Path)).ToList(); // Link the console app executable OutputFiles.AddRange(ToolChain.LinkAllFiles(ConsoleAppLinkEvironment, false, ActionGraph)); } foreach (FileItem Executable in Executables) { OutputFiles.AddRange(ToolChain.PostBuild(Executable, BinaryLinkEnvironment, ActionGraph)); } return(OutputFiles); }
/// <summary> /// Builds the binary. /// </summary> /// <param name="Target">Rules for the target being built</param> /// <param name="ToolChain">The toolchain which to use for building</param> /// <param name="CompileEnvironment">The environment to compile the binary in</param> /// <param name="LinkEnvironment">The environment to link the binary in</param> /// <param name="SingleFileToCompile">If non-null, specifies a single cpp file to be compiled</param> /// <param name="WorkingSet">The working set of source files</param> /// <param name="ExeDir">Directory containing the output executable</param> /// <param name="Makefile">The makefile to add actions to</param> /// <returns>Set of built products</returns> public List <FileItem> Build(ReadOnlyTargetRules Target, UEToolChain ToolChain, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment, FileReference SingleFileToCompile, ISourceFileWorkingSet WorkingSet, DirectoryReference ExeDir, TargetMakefile Makefile) { // Return nothing if we're using precompiled binaries. If we're not linking, we might want just one module to be compiled (eg. a foreign plugin), so allow any actions to run. if (bUsePrecompiled && !Target.bDisableLinking) { return(new List <FileItem>()); } // Setup linking environment. LinkEnvironment BinaryLinkEnvironment = SetupBinaryLinkEnvironment(Target, ToolChain, LinkEnvironment, CompileEnvironment, SingleFileToCompile, WorkingSet, ExeDir, Makefile); // If we're generating projects, we only need include paths and definitions, there is no need to run the linking logic. if (ProjectFileGenerator.bGenerateProjectFiles) { return(BinaryLinkEnvironment.InputFiles); } // If linking is disabled, our build products are just the compiled object files if (Target.bDisableLinking) { return(BinaryLinkEnvironment.InputFiles); } // Generate import libraries as a separate step List <FileItem> OutputFiles = new List <FileItem>(); if (bCreateImportLibrarySeparately) { // Mark the link environment as cross-referenced. BinaryLinkEnvironment.bIsCrossReferenced = true; if (BinaryLinkEnvironment.Platform != UnrealTargetPlatform.Mac && BinaryLinkEnvironment.Platform != UnrealTargetPlatform.Linux && BinaryLinkEnvironment.Platform != UnrealTargetPlatform.LinuxAArch64) { // Create the import library. OutputFiles.AddRange(ToolChain.LinkAllFiles(BinaryLinkEnvironment, true, Makefile.Actions)); } } // Link the binary. FileItem[] Executables = ToolChain.LinkAllFiles(BinaryLinkEnvironment, false, Makefile.Actions); OutputFiles.AddRange(Executables); // Save all the output items for this binary. This is used for hot-reload, and excludes any items added in PostBuild (such as additional files copied into the app). if (Target.LinkType == TargetLinkType.Modular) { Makefile.ModuleNameToOutputItems[PrimaryModule.Name] = OutputFiles.ToArray(); } // Produce additional console app if requested if (bBuildAdditionalConsoleApp) { // Produce additional binary but link it as a console app LinkEnvironment ConsoleAppLinkEvironment = new LinkEnvironment(BinaryLinkEnvironment); ConsoleAppLinkEvironment.bIsBuildingConsoleApplication = true; ConsoleAppLinkEvironment.WindowsEntryPointOverride = "WinMainCRTStartup"; // For WinMain() instead of "main()" for Launch module ConsoleAppLinkEvironment.OutputFilePaths = ConsoleAppLinkEvironment.OutputFilePaths.Select(Path => GetAdditionalConsoleAppPath(Path)).ToList(); // Link the console app executable FileItem[] ConsoleAppOutputFiles = ToolChain.LinkAllFiles(ConsoleAppLinkEvironment, false, Makefile.Actions); OutputFiles.AddRange(ConsoleAppOutputFiles); foreach (FileItem Executable in ConsoleAppOutputFiles) { OutputFiles.AddRange(ToolChain.PostBuild(Executable, ConsoleAppLinkEvironment, Makefile.Actions)); } } foreach (FileItem Executable in Executables) { OutputFiles.AddRange(ToolChain.PostBuild(Executable, BinaryLinkEnvironment, Makefile.Actions)); } return(OutputFiles); }
/// <summary> /// Builds the binary. /// </summary> /// <param name="Target">Rules for the target being built</param> /// <param name="ToolChain">The toolchain which to use for building</param> /// <param name="CompileEnvironment">The environment to compile the binary in</param> /// <param name="LinkEnvironment">The environment to link the binary in</param> /// <param name="SharedPCHs">List of templates for shared PCHs</param> /// <param name="WorkingSet">The working set of source files</param> /// <param name="ActionGraph">Graph to add build actions to</param> /// <returns>Set of built products</returns> public IEnumerable <FileItem> Build(ReadOnlyTargetRules Target, UEToolChain ToolChain, CppCompileEnvironment CompileEnvironment, LinkEnvironment LinkEnvironment, List <PrecompiledHeaderTemplate> SharedPCHs, ISourceFileWorkingSet WorkingSet, ActionGraph ActionGraph) { // Return nothing if we're using precompiled binaries if (bUsePrecompiled) { return(new List <FileItem>()); } // Setup linking environment. LinkEnvironment BinaryLinkEnvironment = SetupBinaryLinkEnvironment(Target, ToolChain, LinkEnvironment, CompileEnvironment, SharedPCHs, WorkingSet, ActionGraph); // If we're generating projects, we only need include paths and definitions, there is no need to run the linking logic. if (ProjectFileGenerator.bGenerateProjectFiles) { return(BinaryLinkEnvironment.InputFiles); } // If linking is disabled, our build products are just the compiled object files if (Target.bDisableLinking) { return(BinaryLinkEnvironment.InputFiles); } // Generate import libraries as a separate step List <FileItem> OutputFiles = new List <FileItem>(); if (bCreateImportLibrarySeparately) { // Mark the link environment as cross-referenced. BinaryLinkEnvironment.bIsCrossReferenced = true; if (BinaryLinkEnvironment.Platform != CppPlatform.Mac && BinaryLinkEnvironment.Platform != CppPlatform.Linux) { // Create the import library. OutputFiles.AddRange(ToolChain.LinkAllFiles(BinaryLinkEnvironment, true, ActionGraph)); } } // Link the binary. FileItem[] Executables = ToolChain.LinkAllFiles(BinaryLinkEnvironment, false, ActionGraph); OutputFiles.AddRange(Executables); // Produce additional console app if requested if (bBuildAdditionalConsoleApp) { // Produce additional binary but link it as a console app LinkEnvironment ConsoleAppLinkEvironment = new LinkEnvironment(BinaryLinkEnvironment); ConsoleAppLinkEvironment.bIsBuildingConsoleApplication = true; ConsoleAppLinkEvironment.WindowsEntryPointOverride = "WinMainCRTStartup"; // For WinMain() instead of "main()" for Launch module ConsoleAppLinkEvironment.OutputFilePaths = ConsoleAppLinkEvironment.OutputFilePaths.Select(Path => GetAdditionalConsoleAppPath(Path)).ToList(); // Link the console app executable OutputFiles.AddRange(ToolChain.LinkAllFiles(ConsoleAppLinkEvironment, false, ActionGraph)); } foreach (FileItem Executable in Executables) { OutputFiles.AddRange(ToolChain.PostBuild(Executable, BinaryLinkEnvironment, ActionGraph)); } return(OutputFiles); }
private List <FileItem> SetupOutputFiles(UEToolChain ToolChain, ref LinkEnvironment BinaryLinkEnvironment, ActionGraph ActionGraph) { // Early exits first if (ProjectFileGenerator.bGenerateProjectFiles) { // We're generating projects. Since we only need include paths and definitions, there is no need // to go ahead and run through the linking logic. return(BinaryLinkEnvironment.InputFiles); } if (BuildConfiguration.bDisableLinking) { // We don't need linked binaries return(BinaryLinkEnvironment.InputFiles); } if (BuildConfiguration.bEnableCodeAnalysis) { // We're only analyzing code, so we won't actually link any executables. Instead, our output // files will simply be the .obj files that were compiled during static analysis. return(BinaryLinkEnvironment.InputFiles); } if (BuildConfiguration.bRunUnrealCodeAnalyzer) { // // Create actions to analyze *.includes files and provide suggestions on how to modify PCH. // return(CreateOutputFilesForUCA(BinaryLinkEnvironment, ActionGraph)); } if (!string.IsNullOrEmpty(BuildConfiguration.SingleFileToCompile)) { return(BinaryLinkEnvironment.InputFiles); } // // Regular linking action. // List <FileItem> OutputFiles = new List <FileItem>(); if (bCreateImportLibrarySeparately) { // Mark the link environment as cross-referenced. BinaryLinkEnvironment.Config.bIsCrossReferenced = true; if (BinaryLinkEnvironment.Config.Platform != CPPTargetPlatform.Mac && BinaryLinkEnvironment.Config.Platform != CPPTargetPlatform.Linux) { // Create the import library. OutputFiles.AddRange(ToolChain.LinkAllFiles(BinaryLinkEnvironment, true, ActionGraph)); } } BinaryLinkEnvironment.Config.bIncludeDependentLibrariesInLibrary = bIncludeDependentLibrariesInLibrary; // Link the binary. FileItem[] Executables = ToolChain.LinkAllFiles(BinaryLinkEnvironment, false, ActionGraph); OutputFiles.AddRange(Executables); // Produce additional console app if requested if (Config.bBuildAdditionalConsoleApp) { // Produce additional binary but link it as a console app LinkEnvironment ConsoleAppLinkEvironment = BinaryLinkEnvironment.DeepCopy(); ConsoleAppLinkEvironment.Config.bIsBuildingConsoleApplication = true; ConsoleAppLinkEvironment.Config.WindowsEntryPointOverride = "WinMainCRTStartup"; // For WinMain() instead of "main()" for Launch module ConsoleAppLinkEvironment.Config.OutputFilePaths = ConsoleAppLinkEvironment.Config.OutputFilePaths.Select(Path => GetAdditionalConsoleAppPath(Path)).ToList(); // Link the console app executable OutputFiles.AddRange(ToolChain.LinkAllFiles(ConsoleAppLinkEvironment, false, ActionGraph)); } foreach (FileItem Executable in Executables) { OutputFiles.AddRange(ToolChain.PostBuild(Executable, BinaryLinkEnvironment, ActionGraph)); } return(OutputFiles); }
private List<FileItem> SetupOutputFiles(UEToolChain ToolChain, ref LinkEnvironment BinaryLinkEnvironment) { // Early exits first if (ProjectFileGenerator.bGenerateProjectFiles) { // We're generating projects. Since we only need include paths and definitions, there is no need // to go ahead and run through the linking logic. return BinaryLinkEnvironment.InputFiles; } if (BuildConfiguration.bDisableLinking) { // We don't need linked binaries return BinaryLinkEnvironment.InputFiles; } if (BuildConfiguration.bEnableCodeAnalysis) { // We're only analyzing code, so we won't actually link any executables. Instead, our output // files will simply be the .obj files that were compiled during static analysis. return BinaryLinkEnvironment.InputFiles; } if (BuildConfiguration.bRunUnrealCodeAnalyzer) { // // Create actions to analyze *.includes files and provide suggestions on how to modify PCH. // return CreateOutputFilesForUCA(BinaryLinkEnvironment); } if (!string.IsNullOrEmpty(BuildConfiguration.SingleFileToCompile)) { return BinaryLinkEnvironment.InputFiles; } // // Regular linking action. // List<FileItem> OutputFiles = new List<FileItem>(); if (bCreateImportLibrarySeparately) { // Mark the link environment as cross-referenced. BinaryLinkEnvironment.Config.bIsCrossReferenced = true; if (BinaryLinkEnvironment.Config.Target.Platform != CPPTargetPlatform.Mac && BinaryLinkEnvironment.Config.Target.Platform != CPPTargetPlatform.Linux) { // Create the import library. OutputFiles.AddRange(ToolChain.LinkAllFiles(BinaryLinkEnvironment, true)); } } BinaryLinkEnvironment.Config.bIncludeDependentLibrariesInLibrary = bIncludeDependentLibrariesInLibrary; // Link the binary. FileItem[] Executables = ToolChain.LinkAllFiles(BinaryLinkEnvironment, false); OutputFiles.AddRange(Executables); // Produce additional console app if requested if (Config.bBuildAdditionalConsoleApp) { // Produce additional binary but link it as a console app LinkEnvironment ConsoleAppLinkEvironment = BinaryLinkEnvironment.DeepCopy(); ConsoleAppLinkEvironment.Config.bIsBuildingConsoleApplication = true; ConsoleAppLinkEvironment.Config.WindowsEntryPointOverride = "WinMainCRTStartup"; // For WinMain() instead of "main()" for Launch module ConsoleAppLinkEvironment.Config.OutputFilePaths = ConsoleAppLinkEvironment.Config.OutputFilePaths.Select(Path => GetAdditionalConsoleAppPath(Path)).ToList(); // Link the console app executable OutputFiles.AddRange(ToolChain.LinkAllFiles(ConsoleAppLinkEvironment, false)); } foreach (FileItem Executable in Executables) { OutputFiles.AddRange(ToolChain.PostBuild(Executable, BinaryLinkEnvironment)); } return OutputFiles; }