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;
}
