/// <summary>
/// Gets everything that this file includes from our cache (direct and indirect!)
/// </summary>
/// <param name="AbsoluteFilePath">Path to the file</param>
/// <returns>The list of includes</returns>
public List <FileItem> GetDependenciesForFile(FileReference AbsoluteFilePath)
{
FlatCPPIncludeDependencyInfo DependencyInfo;
if (DependencyMap.TryGetValue(AbsoluteFilePath, out DependencyInfo))
{
// Update our transient cache of FileItems for each of the included files
if (DependencyInfo.IncludeFileItems == null)
{
DependencyInfo.IncludeFileItems = new List <FileItem>(DependencyInfo.Includes.Count);
foreach (FileReference Dependency in DependencyInfo.Includes)
{
DependencyInfo.IncludeFileItems.Add(FileItem.GetItemByFileReference(Dependency));
}
}
return(DependencyInfo.IncludeFileItems);
}
return(null);
}
public override CPPOutput CompileCPPFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, string ModuleName, List <Action> Actions)
{
// Create a compile action for each source file.
CPPOutput Result = new CPPOutput();
foreach (FileItem SourceFile in InputFiles)
{
FileItem ObjectFile = FileItem.GetItemByFileReference(FileReference.Combine(OutputDir, Path.GetFileName(SourceFile.AbsolutePath) + ".xo"));
Action CompileAction = new Action(ActionType.Compile);
CompileAction.CommandDescription = "FakeCompile";
CompileAction.CommandPath = BuildHostPlatform.Current.Shell;
// we use type/cat instead of copy so that timestamp gets updated
if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Win64)
{
CompileAction.CommandArguments = String.Format("/C \"type \"{0}\" > \"{1}\"\"", SourceFile, ObjectFile);
}
else
{
CompileAction.CommandArguments = String.Format("cat {0} > {1}", Utils.EscapeShellArgument(SourceFile.AbsolutePath), Utils.EscapeShellArgument(ObjectFile.AbsolutePath));
}
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory;
CompileAction.PrerequisiteItems.Add(SourceFile);
CompileAction.ProducedItems.Add(ObjectFile);
CompileAction.StatusDescription = ObjectFile.Location.GetFileName();
CompileAction.bCanExecuteRemotely = false;
Result.ObjectFiles.Add(ObjectFile);
foreach (FileItem ForceIncludeFile in CompileEnvironment.ForceIncludeFiles)
{
CompileAction.PrerequisiteItems.Add(ForceIncludeFile);
}
Actions.Add(CompileAction);
}
return(Result);
}
private LinkEnvironment SetupBinaryLinkEnvironment(ReadOnlyTargetRules Target, UEToolChain ToolChain, LinkEnvironment LinkEnvironment, CppCompileEnvironment CompileEnvironment, FileReference SingleFileToCompile, ISourceFileWorkingSet WorkingSet, DirectoryReference ExeDir, TargetMakefile Makefile)
{
LinkEnvironment BinaryLinkEnvironment = new LinkEnvironment(LinkEnvironment);
HashSet <UEBuildModule> LinkEnvironmentVisitedModules = new HashSet <UEBuildModule>();
List <UEBuildBinary> BinaryDependencies = new List <UEBuildBinary>();
CppCompileEnvironment BinaryCompileEnvironment = CreateBinaryCompileEnvironment(CompileEnvironment);
if (BinaryCompileEnvironment.bUseSharedBuildEnvironment && Target.ProjectFile != null && IntermediateDirectory.IsUnderDirectory(Target.ProjectFile.Directory))
{
BinaryCompileEnvironment.bUseSharedBuildEnvironment = false;
}
foreach (UEBuildModule Module in Modules)
{
List <FileItem> LinkInputFiles;
if (Module.Binary == null || Module.Binary == this)
{
// Compile each module.
Log.TraceVerbose("Compile module: " + Module.Name);
LinkInputFiles = Module.Compile(Target, ToolChain, BinaryCompileEnvironment, SingleFileToCompile, WorkingSet, Makefile);
// Save the module outputs. In monolithic builds, this is just the object files.
if (Target.LinkType == TargetLinkType.Monolithic)
{
Makefile.ModuleNameToOutputItems[Module.Name] = LinkInputFiles.ToArray();
}
// NOTE: Because of 'Shared PCHs', in monolithic builds the same PCH file may appear as a link input
// multiple times for a single binary. We'll check for that here, and only add it once. This avoids
// a linker warning about redundant .obj files.
foreach (FileItem LinkInputFile in LinkInputFiles)
{
if (!BinaryLinkEnvironment.InputFiles.Contains(LinkInputFile))
{
BinaryLinkEnvironment.InputFiles.Add(LinkInputFile);
}
}
// Force a reference to initialize module for this binary
if (Module.Rules.bRequiresImplementModule.Value)
{
BinaryLinkEnvironment.IncludeFunctions.Add(String.Format("IMPLEMENT_MODULE_{0}", Module.Name));
}
}
else
{
BinaryDependencies.Add(Module.Binary);
}
// Allow the module to modify the link environment for the binary.
Module.SetupPrivateLinkEnvironment(this, BinaryLinkEnvironment, BinaryDependencies, LinkEnvironmentVisitedModules, ExeDir);
}
// Allow the binary dependencies to modify the link environment.
foreach (UEBuildBinary BinaryDependency in BinaryDependencies)
{
BinaryDependency.SetupDependentLinkEnvironment(BinaryLinkEnvironment);
}
// Set the link output file.
BinaryLinkEnvironment.OutputFilePaths = OutputFilePaths.ToList();
// Set whether the link is allowed to have exports.
BinaryLinkEnvironment.bHasExports = bAllowExports;
// Set the output folder for intermediate files
BinaryLinkEnvironment.IntermediateDirectory = IntermediateDirectory;
// Put the non-executable output files (PDB, import library, etc) in the same directory as the production
BinaryLinkEnvironment.OutputDirectory = OutputFilePaths[0].Directory;
// Setup link output type
BinaryLinkEnvironment.bIsBuildingDLL = IsBuildingDll(Type);
BinaryLinkEnvironment.bIsBuildingLibrary = IsBuildingLibrary(Type);
// If we don't have any resource file, use the default or compile a custom one for this module
if (BinaryLinkEnvironment.Platform == UnrealTargetPlatform.Win32 || BinaryLinkEnvironment.Platform == UnrealTargetPlatform.Win64)
{
// Figure out if this binary has any custom resource files. Hacky check to ignore the resource file in the Launch module, since it contains dialogs that the engine needs and always needs to be included.
FileItem[] CustomResourceFiles = BinaryLinkEnvironment.InputFiles.Where(x => x.Location.HasExtension(".res") && !x.Location.FullName.EndsWith("\\Launch\\PCLaunch.rc.res", StringComparison.OrdinalIgnoreCase)).ToArray();
if (CustomResourceFiles.Length == 0)
{
if (BinaryLinkEnvironment.DefaultResourceFiles.Count > 0)
{
// Use the default resource file if possible
BinaryLinkEnvironment.InputFiles.AddRange(BinaryLinkEnvironment.DefaultResourceFiles);
}
else
{
// Get the intermediate directory
DirectoryReference ResourceIntermediateDirectory = BinaryLinkEnvironment.IntermediateDirectory;
// Create a compile environment for resource files
CppCompileEnvironment ResourceCompileEnvironment = new CppCompileEnvironment(BinaryCompileEnvironment);
// @todo: This should be in some Windows code somewhere...
// Set the original file name macro; used in Default.rc2 to set the binary metadata fields.
ResourceCompileEnvironment.Definitions.Add("ORIGINAL_FILE_NAME=\"" + OutputFilePaths[0].GetFileName() + "\"");
// Set the other version fields
ResourceCompileEnvironment.Definitions.Add(String.Format("BUILT_FROM_CHANGELIST={0}", Target.Version.Changelist));
ResourceCompileEnvironment.Definitions.Add(String.Format("BUILD_VERSION={0}", Target.BuildVersion));
// Otherwise compile the default resource file per-binary, so that it gets the correct ORIGINAL_FILE_NAME macro.
FileItem DefaultResourceFile = FileItem.GetItemByFileReference(FileReference.Combine(UnrealBuildTool.EngineDirectory, "Build", "Windows", "Resources", "Default.rc2"));
CPPOutput DefaultResourceOutput = ToolChain.CompileRCFiles(ResourceCompileEnvironment, new List <FileItem> {
DefaultResourceFile
}, ResourceIntermediateDirectory, Makefile.Actions);
BinaryLinkEnvironment.InputFiles.AddRange(DefaultResourceOutput.ObjectFiles);
}
}
}
// Add all the common resource files
BinaryLinkEnvironment.InputFiles.AddRange(BinaryLinkEnvironment.CommonResourceFiles);
return(BinaryLinkEnvironment);
}
/// <summary>
/// Finds the files directly or indirectly included by the given C++ file.
/// </summary>
/// <param name="CPPFile">C++ file to get the dependencies for.</param>
/// <param name="Result">List of CPPFile dependencies.</param>
/// <returns>false if CPPFile is still being processed further down the callstack, true otherwise.</returns>
public static bool FindAndCacheAllIncludedFiles(UEBuildTarget Target, FileItem CPPFile, UEBuildPlatform BuildPlatform, CPPIncludeInfo CPPIncludeInfo, ref IncludedFilesSet Result, bool bOnlyCachedDependencies)
{
IncludedFilesSet IncludedFileList;
Dictionary <FileItem, IncludedFilesSet> IncludedFilesMap = bOnlyCachedDependencies ? OnlyCachedIncludedFilesMap : ExhaustiveIncludedFilesMap;
if (!IncludedFilesMap.TryGetValue(CPPFile, out IncludedFileList))
{
DateTime TimerStartTime = DateTime.UtcNow;
IncludedFileList = new IncludedFilesSet();
// Add an uninitialized entry for the include file to avoid infinitely recursing on include file loops.
IncludedFilesMap.Add(CPPFile, IncludedFileList);
// Gather a list of names of files directly included by this C++ file.
List <DependencyInclude> DirectIncludes = GetDirectIncludeDependencies(Target, CPPFile, BuildPlatform, bOnlyCachedDependencies: bOnlyCachedDependencies);
// Build a list of the unique set of files that are included by this file.
HashSet <FileItem> DirectlyIncludedFiles = new HashSet <FileItem>();
// require a for loop here because we need to keep track of the index in the list.
for (int DirectlyIncludedFileNameIndex = 0; DirectlyIncludedFileNameIndex < DirectIncludes.Count; ++DirectlyIncludedFileNameIndex)
{
// Resolve the included file name to an actual file.
DependencyInclude DirectInclude = DirectIncludes[DirectlyIncludedFileNameIndex];
if (!DirectInclude.HasAttemptedResolve ||
// ignore any preexisting resolve cache if we are not configured to use it.
!BuildConfiguration.bUseIncludeDependencyResolveCache ||
// if we are testing the resolve cache, we force UBT to resolve every time to look for conflicts
BuildConfiguration.bTestIncludeDependencyResolveCache
)
{
++TotalDirectIncludeResolveCacheMisses;
// search the include paths to resolve the file
FileItem DirectIncludeResolvedFile = CPPEnvironment.FindIncludedFile(DirectInclude.IncludeName, !BuildConfiguration.bCheckExternalHeadersForModification, CPPIncludeInfo.GetIncludesPathsToSearch(CPPFile), CPPIncludeInfo.IncludeFileSearchDictionary);
if (DirectIncludeResolvedFile != null)
{
DirectlyIncludedFiles.Add(DirectIncludeResolvedFile);
}
IncludeDependencyCache[Target].CacheResolvedIncludeFullPath(CPPFile, DirectlyIncludedFileNameIndex, DirectIncludeResolvedFile != null ? DirectIncludeResolvedFile.Reference : null);
}
else
{
// we might have cached an attempt to resolve the file, but couldn't actually find the file (system headers, etc).
if (DirectInclude.IncludeResolvedNameIfSuccessful != null)
{
DirectlyIncludedFiles.Add(FileItem.GetItemByFileReference(DirectInclude.IncludeResolvedNameIfSuccessful));
}
}
}
TotalDirectIncludeResolves += DirectIncludes.Count;
// Convert the dictionary of files included by this file into a list.
foreach (FileItem DirectlyIncludedFile in DirectlyIncludedFiles)
{
// Add the file we're directly including
IncludedFileList.Add(DirectlyIncludedFile);
// Also add all of the indirectly included files!
if (FindAndCacheAllIncludedFiles(Target, DirectlyIncludedFile, BuildPlatform, CPPIncludeInfo, ref IncludedFileList, bOnlyCachedDependencies: bOnlyCachedDependencies) == false)
{
// DirectlyIncludedFile is a circular dependency which is still being processed
// further down the callstack. Add this file to its circular dependencies list
// so that it can update its dependencies later.
IncludedFilesSet DirectlyIncludedFileIncludedFileList;
if (IncludedFilesMap.TryGetValue(DirectlyIncludedFile, out DirectlyIncludedFileIncludedFileList))
{
DirectlyIncludedFileIncludedFileList.CircularDependencies.Add(CPPFile);
}
}
}
// All dependencies have been processed by now so update all circular dependencies
// with the full list.
foreach (FileItem CircularDependency in IncludedFileList.CircularDependencies)
{
IncludedFilesSet CircularDependencyIncludedFiles = IncludedFilesMap[CircularDependency];
foreach (FileItem IncludedFile in IncludedFileList)
{
CircularDependencyIncludedFiles.Add(IncludedFile);
}
}
// No need to keep this around anymore.
IncludedFileList.CircularDependencies.Clear();
// Done collecting files.
IncludedFileList.bIsInitialized = true;
TimeSpan TimerDuration = DateTime.UtcNow - TimerStartTime;
TotalTimeSpentGettingIncludes += TimerDuration.TotalSeconds;
}
if (IncludedFileList.bIsInitialized)
{
// Copy the list of files included by this file into the result list.
foreach (FileItem IncludedFile in IncludedFileList)
{
// If the result list doesn't contain this file yet, add the file and the files it includes.
// NOTE: For some reason in .NET 4, Add() is over twice as fast as calling UnionWith() on the set
Result.Add(IncludedFile);
}
return(true);
}
else
{
// The IncludedFileList.bIsInitialized was false because we added a dummy entry further down the call stack. We're already processing
// the include list for this header elsewhere in the stack frame, so we don't need to add anything here.
return(false);
}
}
public override FileItem LinkFiles(LinkEnvironment LinkEnvironment, bool bBuildImportLibraryOnly)
{
var EnvVars = VCEnvironment.SetEnvironment(LinkEnvironment.Config.Target.Platform, false);
if (LinkEnvironment.Config.bIsBuildingDotNetAssembly)
{
return(FileItem.GetItemByFileReference(LinkEnvironment.Config.OutputFilePath));
}
bool bIsBuildingLibrary = LinkEnvironment.Config.bIsBuildingLibrary || bBuildImportLibraryOnly;
bool bIncludeDependentLibrariesInLibrary = bIsBuildingLibrary && LinkEnvironment.Config.bIncludeDependentLibrariesInLibrary;
// Get link arguments.
StringBuilder Arguments = new StringBuilder();
if (bIsBuildingLibrary)
{
AppendLibArguments(LinkEnvironment, Arguments);
}
else
{
AppendLinkArguments(LinkEnvironment, Arguments);
}
// If we're only building an import library, add the '/DEF' option that tells the LIB utility
// to simply create a .LIB file and .EXP file, and don't bother validating imports
if (bBuildImportLibraryOnly)
{
Arguments.Append(" /DEF");
// Ensure that the import library references the correct filename for the linked binary.
Arguments.AppendFormat(" /NAME:\"{0}\"", LinkEnvironment.Config.OutputFilePath.GetFileName());
}
// Add delay loaded DLLs.
if (!bIsBuildingLibrary)
{
// Delay-load these DLLs.
foreach (string DelayLoadDLL in LinkEnvironment.Config.DelayLoadDLLs)
{
Arguments.AppendFormat(" /DELAYLOAD:\"{0}\"", DelayLoadDLL);
}
}
// @todo UE4 DLL: Why do I need LIBPATHs to build only export libraries with /DEF? (tbbmalloc.lib)
if (!LinkEnvironment.Config.bIsBuildingLibrary || (LinkEnvironment.Config.bIsBuildingLibrary && bIncludeDependentLibrariesInLibrary))
{
// Add the library paths to the argument list.
foreach (string LibraryPath in LinkEnvironment.Config.LibraryPaths)
{
Arguments.AppendFormat(" /LIBPATH:\"{0}\"", LibraryPath);
}
// Add the excluded default libraries to the argument list.
foreach (string ExcludedLibrary in LinkEnvironment.Config.ExcludedLibraries)
{
Arguments.AppendFormat(" /NODEFAULTLIB:\"{0}\"", ExcludedLibrary);
}
}
// For targets that are cross-referenced, we don't want to write a LIB file during the link step as that
// file will clobber the import library we went out of our way to generate during an earlier step. This
// file is not needed for our builds, but there is no way to prevent MSVC from generating it when
// linking targets that have exports. We don't want this to clobber our LIB file and invalidate the
// existing timstamp, so instead we simply emit it with a different name
FileReference ImportLibraryFilePath = FileReference.Combine(LinkEnvironment.Config.IntermediateDirectory,
LinkEnvironment.Config.OutputFilePath.GetFileNameWithoutExtension() + ".lib");
if (LinkEnvironment.Config.bIsCrossReferenced && !bBuildImportLibraryOnly)
{
ImportLibraryFilePath += ".suppressed";
}
FileItem OutputFile;
if (bBuildImportLibraryOnly)
{
OutputFile = FileItem.GetItemByFileReference(ImportLibraryFilePath);
}
else
{
OutputFile = FileItem.GetItemByFileReference(LinkEnvironment.Config.OutputFilePath);
OutputFile.bNeedsHotReloadNumbersDLLCleanUp = LinkEnvironment.Config.bIsBuildingDLL;
}
List <FileItem> ProducedItems = new List <FileItem>();
ProducedItems.Add(OutputFile);
List <FileItem> PrerequisiteItems = new List <FileItem>();
// Add the input files to a response file, and pass the response file on the command-line.
List <string> InputFileNames = new List <string>();
foreach (FileItem InputFile in LinkEnvironment.InputFiles)
{
InputFileNames.Add(string.Format("\"{0}\"", InputFile.AbsolutePath));
PrerequisiteItems.Add(InputFile);
}
if (!bBuildImportLibraryOnly)
{
// Add input libraries as prerequisites, too!
foreach (FileItem InputLibrary in LinkEnvironment.InputLibraries)
{
InputFileNames.Add(string.Format("\"{0}\"", InputLibrary.AbsolutePath));
PrerequisiteItems.Add(InputLibrary);
}
}
if (!bIsBuildingLibrary || (LinkEnvironment.Config.bIsBuildingLibrary && bIncludeDependentLibrariesInLibrary))
{
foreach (string AdditionalLibrary in LinkEnvironment.Config.AdditionalLibraries)
{
InputFileNames.Add(string.Format("\"{0}\"", AdditionalLibrary));
// If the library file name has a relative path attached (rather than relying on additional
// lib directories), then we'll add it to our prerequisites list. This will allow UBT to detect
// when the binary needs to be relinked because a dependent external library has changed.
//if( !String.IsNullOrEmpty( Path.GetDirectoryName( AdditionalLibrary ) ) )
{
PrerequisiteItems.Add(FileItem.GetItemByPath(AdditionalLibrary));
}
}
}
// Create a response file for the linker
FileReference ResponseFileName = GetResponseFileName(LinkEnvironment, OutputFile);
// Never create response files when we are only generating IntelliSense data
if (!ProjectFileGenerator.bGenerateProjectFiles)
{
ResponseFile.Create(ResponseFileName, InputFileNames);
}
Arguments.AppendFormat(" @\"{0}\"", ResponseFileName);
// Add the output file to the command-line.
Arguments.AppendFormat(" /OUT:\"{0}\"", OutputFile.AbsolutePath);
if (bBuildImportLibraryOnly || (LinkEnvironment.Config.bHasExports && !bIsBuildingLibrary))
{
// An export file is written to the output directory implicitly; add it to the produced items list.
FileReference ExportFilePath = ImportLibraryFilePath.ChangeExtension(".exp");
FileItem ExportFile = FileItem.GetItemByFileReference(ExportFilePath);
ProducedItems.Add(ExportFile);
}
if (!bIsBuildingLibrary)
{
// Xbox 360 LTCG does not seem to produce those.
if (LinkEnvironment.Config.bHasExports &&
(LinkEnvironment.Config.Target.Configuration != CPPTargetConfiguration.Shipping))
{
// Write the import library to the output directory for nFringe support.
FileItem ImportLibraryFile = FileItem.GetItemByFileReference(ImportLibraryFilePath);
Arguments.AppendFormat(" /IMPLIB:\"{0}\"", ImportLibraryFilePath);
ProducedItems.Add(ImportLibraryFile);
}
if (LinkEnvironment.Config.bCreateDebugInfo)
{
// Write the PDB file to the output directory.
FileReference PDBFilePath = FileReference.Combine(LinkEnvironment.Config.OutputDirectory, Path.GetFileNameWithoutExtension(OutputFile.AbsolutePath) + ".pdb");
FileItem PDBFile = FileItem.GetItemByFileReference(PDBFilePath);
Arguments.AppendFormat(" /PDB:\"{0}\"", PDBFilePath);
ProducedItems.Add(PDBFile);
// Write the MAP file to the output directory.
#if false
if (true)
{
string MAPFilePath = Path.Combine(LinkEnvironment.Config.OutputDirectory, Path.GetFileNameWithoutExtension(OutputFile.AbsolutePath) + ".map");
FileItem MAPFile = FileItem.GetItemByFileReference(MAPFilePath);
LinkAction.CommandArguments += string.Format(" /MAP:\"{0}\"", MAPFilePath);
LinkAction.ProducedItems.Add(MAPFile);
}
#endif
}
// Add the additional arguments specified by the environment.
Arguments.Append(LinkEnvironment.Config.AdditionalArguments);
}
// Create an action that invokes the linker.
Action LinkAction = new Action(ActionType.Link);
LinkAction.CommandDescription = "Link";
LinkAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
LinkAction.CommandPath = bIsBuildingLibrary ? EnvVars.LibraryLinkerPath : EnvVars.LinkerPath;
LinkAction.CommandArguments = Arguments.ToString();
LinkAction.ProducedItems.AddRange(ProducedItems);
LinkAction.PrerequisiteItems.AddRange(PrerequisiteItems);
LinkAction.StatusDescription = Path.GetFileName(OutputFile.AbsolutePath);
// Tell the action that we're building an import library here and it should conditionally be
// ignored as a prerequisite for other actions
LinkAction.bProducesImportLibrary = bBuildImportLibraryOnly || LinkEnvironment.Config.bIsBuildingDLL;
// Only execute linking on the local PC.
LinkAction.bCanExecuteRemotely = false;
Log.TraceVerbose(" Linking: " + LinkAction.StatusDescription);
Log.TraceVerbose(" Command: " + LinkAction.CommandArguments);
return(OutputFile);
}
public override CPPOutput CompileCPPFiles(UEBuildTarget Target, CPPEnvironment CompileEnvironment, List <FileItem> SourceFiles, string ModuleName)
{
var EnvVars = VCEnvironment.SetEnvironment(CompileEnvironment.Config.Target.Platform, false);
StringBuilder Arguments = new StringBuilder();
AppendCLArguments_Global(CompileEnvironment, EnvVars, Arguments);
// Add include paths to the argument list.
foreach (string IncludePath in CompileEnvironment.Config.CPPIncludeInfo.IncludePaths)
{
string IncludePathRelative = Utils.CleanDirectorySeparators(Utils.MakePathRelativeTo(IncludePath, Path.Combine(ProjectFileGenerator.RootRelativePath, "Engine/Source")), '/');
Arguments.AppendFormat(" /I \"{0}\"", IncludePathRelative);
}
foreach (string IncludePath in CompileEnvironment.Config.CPPIncludeInfo.SystemIncludePaths)
{
string IncludePathRelative = Utils.CleanDirectorySeparators(Utils.MakePathRelativeTo(IncludePath, Path.Combine(ProjectFileGenerator.RootRelativePath, "Engine/Source")), '/');
Arguments.AppendFormat(" /I \"{0}\"", IncludePathRelative);
}
if (CompileEnvironment.Config.CLRMode == CPPCLRMode.CLREnabled)
{
// Add .NET framework assembly paths. This is needed so that C++/CLI projects
// can reference assemblies with #using, without having to hard code a path in the
// .cpp file to the assembly's location.
foreach (string AssemblyPath in CompileEnvironment.Config.SystemDotNetAssemblyPaths)
{
Arguments.AppendFormat(" /AI \"{0}\"", AssemblyPath);
}
// Add explicit .NET framework assembly references
foreach (string AssemblyName in CompileEnvironment.Config.FrameworkAssemblyDependencies)
{
Arguments.AppendFormat(" /FU \"{0}\"", AssemblyName);
}
// Add private assembly references
foreach (PrivateAssemblyInfo CurAssemblyInfo in CompileEnvironment.PrivateAssemblyDependencies)
{
Arguments.AppendFormat(" /FU \"{0}\"", CurAssemblyInfo.FileItem.AbsolutePath);
}
}
// Add preprocessor definitions to the argument list.
foreach (string Definition in CompileEnvironment.Config.Definitions)
{
// Escape all quotation marks so that they get properly passed with the command line.
var DefinitionArgument = Definition.Contains("\"") ? Definition.Replace("\"", "\\\"") : Definition;
Arguments.AppendFormat(" /D\"{0}\"", DefinitionArgument);
}
var BuildPlatform = UEBuildPlatform.GetBuildPlatformForCPPTargetPlatform(CompileEnvironment.Config.Target.Platform);
// Create a compile action for each source file.
CPPOutput Result = new CPPOutput();
foreach (FileItem SourceFile in SourceFiles)
{
Action CompileAction = new Action(ActionType.Compile);
CompileAction.CommandDescription = "Compile";
StringBuilder FileArguments = new StringBuilder();
bool bIsPlainCFile = Path.GetExtension(SourceFile.AbsolutePath).ToUpperInvariant() == ".C";
// Add the C++ source file and its included files to the prerequisite item list.
AddPrerequisiteSourceFile(Target, BuildPlatform, CompileEnvironment, SourceFile, CompileAction.PrerequisiteItems);
// If this is a CLR file then make sure our dependent assemblies are added as prerequisites
if (CompileEnvironment.Config.CLRMode == CPPCLRMode.CLREnabled)
{
foreach (PrivateAssemblyInfo CurPrivateAssemblyDependency in CompileEnvironment.PrivateAssemblyDependencies)
{
CompileAction.PrerequisiteItems.Add(CurPrivateAssemblyDependency.FileItem);
}
}
bool bEmitsObjectFile = true;
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Create)
{
// Generate a CPP File that just includes the precompiled header.
string PCHCPPFilename = "PCH." + ModuleName + "." + CompileEnvironment.Config.PrecompiledHeaderIncludeFilename.GetFileName() + ".cpp";
FileReference PCHCPPPath = FileReference.Combine(CompileEnvironment.Config.OutputDirectory, PCHCPPFilename);
FileItem PCHCPPFile = FileItem.CreateIntermediateTextFile(
PCHCPPPath,
string.Format("#include \"{0}\"\r\n", CompileEnvironment.Config.PrecompiledHeaderIncludeFilename)
);
// Make sure the original source directory the PCH header file existed in is added as an include
// path -- it might be a private PCH header and we need to make sure that its found!
string OriginalPCHHeaderDirectory = Path.GetDirectoryName(SourceFile.AbsolutePath);
FileArguments.AppendFormat(" /I \"{0}\"", OriginalPCHHeaderDirectory);
var PrecompiledFileExtension = UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.UWP).GetBinaryExtension(UEBuildBinaryType.PrecompiledHeader);
// Add the precompiled header file to the produced items list.
FileItem PrecompiledHeaderFile = FileItem.GetItemByFileReference(
FileReference.Combine(
CompileEnvironment.Config.OutputDirectory,
Path.GetFileName(SourceFile.AbsolutePath) + PrecompiledFileExtension
)
);
CompileAction.ProducedItems.Add(PrecompiledHeaderFile);
Result.PrecompiledHeaderFile = PrecompiledHeaderFile;
// Add the parameters needed to compile the precompiled header file to the command-line.
FileArguments.AppendFormat(" /Yc\"{0}\"", CompileEnvironment.Config.PrecompiledHeaderIncludeFilename);
FileArguments.AppendFormat(" /Fp\"{0}\"", PrecompiledHeaderFile.AbsolutePath);
// If we're creating a PCH that will be used to compile source files for a library, we need
// the compiled modules to retain a reference to PCH's module, so that debugging information
// will be included in the library. This is also required to avoid linker warning "LNK4206"
// when linking an application that uses this library.
if (CompileEnvironment.Config.bIsBuildingLibrary)
{
// NOTE: The symbol name we use here is arbitrary, and all that matters is that it is
// unique per PCH module used in our library
string FakeUniquePCHSymbolName = CompileEnvironment.Config.PrecompiledHeaderIncludeFilename.GetFileNameWithoutExtension();
FileArguments.AppendFormat(" /Yl{0}", FakeUniquePCHSymbolName);
}
FileArguments.AppendFormat(" \"{0}\"", PCHCPPFile.AbsolutePath);
CompileAction.StatusDescription = PCHCPPFilename;
}
else
{
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Include)
{
CompileAction.bIsUsingPCH = true;
CompileAction.PrerequisiteItems.Add(CompileEnvironment.PrecompiledHeaderFile);
FileArguments.AppendFormat(" /Yu\"{0}\"", CompileEnvironment.Config.PCHHeaderNameInCode);
FileArguments.AppendFormat(" /Fp\"{0}\"", CompileEnvironment.PrecompiledHeaderFile.AbsolutePath);
// Is it unsafe to always force inclusion? Clang is doing it, and .generated.cpp files
// won't work otherwise, because they're not located in the context of the module,
// so they can't access the module's PCH without an absolute path.
//if( CompileEnvironment.Config.bForceIncludePrecompiledHeader )
{
// Force include the precompiled header file. This is needed because we may have selected a
// precompiled header that is different than the first direct include in the C++ source file, but
// we still need to make sure that our precompiled header is the first thing included!
FileArguments.AppendFormat(" /FI\"{0}\"", CompileEnvironment.Config.PCHHeaderNameInCode);
}
}
// Add the source file path to the command-line.
FileArguments.AppendFormat(" \"{0}\"", SourceFile.AbsolutePath);
CompileAction.StatusDescription = Path.GetFileName(SourceFile.AbsolutePath);
}
if (bEmitsObjectFile)
{
var ObjectFileExtension = UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.UWP).GetBinaryExtension(UEBuildBinaryType.Object);
// Add the object file to the produced item list.
FileItem ObjectFile = FileItem.GetItemByFileReference(
FileReference.Combine(
CompileEnvironment.Config.OutputDirectory,
Path.GetFileName(SourceFile.AbsolutePath) + ObjectFileExtension
)
);
CompileAction.ProducedItems.Add(ObjectFile);
Result.ObjectFiles.Add(ObjectFile);
FileArguments.AppendFormat(" /Fo\"{0}\"", ObjectFile.AbsolutePath);
}
// Create PDB files if we were configured to do that.
//
// Also, when debug info is off and XGE is enabled, force PDBs, otherwise it will try to share
// a PDB file, which causes PCH creation to be serial rather than parallel (when debug info is disabled)
// --> See https://udn.epicgames.com/lists/showpost.php?id=50619&list=unprog3
if (BuildConfiguration.bUsePDBFiles ||
(BuildConfiguration.bAllowXGE && !CompileEnvironment.Config.bCreateDebugInfo))
{
string PDBFileName;
bool bActionProducesPDB = false;
// All files using the same PCH are required to share the same PDB that was used when compiling the PCH
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Include)
{
PDBFileName = "PCH." + ModuleName + "." + CompileEnvironment.Config.PrecompiledHeaderIncludeFilename.GetFileName();
}
// Files creating a PCH use a PDB per file.
else if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Create)
{
PDBFileName = "PCH." + ModuleName + "." + CompileEnvironment.Config.PrecompiledHeaderIncludeFilename.GetFileName();
bActionProducesPDB = true;
}
// Ungrouped C++ files use a PDB per file.
else if (!bIsPlainCFile)
{
PDBFileName = Path.GetFileName(SourceFile.AbsolutePath);
bActionProducesPDB = true;
}
// Group all plain C files that doesn't use PCH into the same PDB
else
{
PDBFileName = "MiscPlainC";
}
// Specify the PDB file that the compiler should write to.
FileItem PDBFile = FileItem.GetItemByFileReference(
FileReference.Combine(
CompileEnvironment.Config.OutputDirectory,
PDBFileName + ".pdb"
)
);
FileArguments.AppendFormat(" /Fd\"{0}\"", PDBFile.AbsolutePath);
// Only use the PDB as an output file if we want PDBs and this particular action is
// the one that produces the PDB (as opposed to no debug info, where the above code
// is needed, but not the output PDB, or when multiple files share a single PDB, so
// only the action that generates it should count it as output directly)
if (BuildConfiguration.bUsePDBFiles && bActionProducesPDB)
{
CompileAction.ProducedItems.Add(PDBFile);
Result.DebugDataFiles.Add(PDBFile);
}
}
// Add C or C++ specific compiler arguments.
if (bIsPlainCFile)
{
AppendCLArguments_C(FileArguments);
}
else
{
AppendCLArguments_CPP(CompileEnvironment, FileArguments);
}
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
CompileAction.CommandPath = EnvVars.CompilerPath;
CompileAction.CommandArguments = Arguments.ToString() + FileArguments.ToString() + CompileEnvironment.Config.AdditionalArguments;
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Create)
{
Log.TraceVerbose("Creating PCH: " + CompileEnvironment.Config.PrecompiledHeaderIncludeFilename);
Log.TraceVerbose(" Command: " + CompileAction.CommandArguments);
}
else
{
Log.TraceVerbose(" Compiling: " + CompileAction.StatusDescription);
Log.TraceVerbose(" Command: " + CompileAction.CommandArguments);
}
// VC++ always outputs the source file name being compiled, so we don't need to emit this ourselves
CompileAction.bShouldOutputStatusDescription = false;
// Don't farm out creation of precompiled headers as it is the critical path task.
CompileAction.bCanExecuteRemotely =
CompileEnvironment.Config.PrecompiledHeaderAction != PrecompiledHeaderAction.Create ||
BuildConfiguration.bAllowRemotelyCompiledPCHs
;
// @todo: XGE has problems remote compiling C++/CLI files that use .NET Framework 4.0
if (CompileEnvironment.Config.CLRMode == CPPCLRMode.CLREnabled)
{
CompileAction.bCanExecuteRemotely = false;
}
}
return(Result);
}
/// <summary>
/// Patches a set of actions for use with live coding. The new action list will output object files to a different location.
/// </summary>
/// <param name="Actions">Set of actions</param>
/// <param name="OriginalFileToPatchedFile">Dictionary that receives a map of original object file to patched object file</param>
public static void PatchActionGraphForLiveCoding(IEnumerable <Action> Actions, Dictionary <FileReference, FileReference> OriginalFileToPatchedFile)
{
foreach (Action Action in Actions)
{
if (Action.ActionType == ActionType.Compile)
{
if (!Action.CommandPath.GetFileName().Equals("cl-filter.exe", StringComparison.OrdinalIgnoreCase))
{
throw new BuildException("Unable to patch action graph - unexpected executable in compile action ({0})", Action.CommandPath);
}
List <string> Arguments = Utils.ParseArgumentList(Action.CommandArguments);
// Find the index of the cl-filter argument delimiter
int DelimiterIdx = Arguments.IndexOf("--");
if (DelimiterIdx == -1)
{
throw new BuildException("Unable to patch action graph - missing '--' delimiter to cl-filter");
}
// Fix the dependencies path
const string DependenciesPrefix = "-dependencies=";
int DependenciesIdx = 0;
for (;; DependenciesIdx++)
{
if (DependenciesIdx == DelimiterIdx)
{
throw new BuildException("Unable to patch action graph - missing '{0}' argument to cl-filter", DependenciesPrefix);
}
else if (Arguments[DependenciesIdx].StartsWith(DependenciesPrefix, StringComparison.OrdinalIgnoreCase))
{
break;
}
}
FileReference OldDependenciesFile = new FileReference(Arguments[DependenciesIdx].Substring(DependenciesPrefix.Length));
FileItem OldDependenciesFileItem = Action.ProducedItems.First(x => x.Location == OldDependenciesFile);
Action.ProducedItems.Remove(OldDependenciesFileItem);
FileReference NewDependenciesFile = OldDependenciesFile.ChangeExtension(".lc.response");
FileItem NewDependenciesFileItem = FileItem.GetItemByFileReference(NewDependenciesFile);
Action.ProducedItems.Add(NewDependenciesFileItem);
Arguments[DependenciesIdx] = DependenciesPrefix + NewDependenciesFile.FullName;
// Fix the response file
int ResponseFileIdx = DelimiterIdx + 1;
for (; ; ResponseFileIdx++)
{
if (ResponseFileIdx == Arguments.Count)
{
throw new BuildException("Unable to patch action graph - missing response file argument to cl-filter");
}
else if (Arguments[ResponseFileIdx].StartsWith("@", StringComparison.Ordinal))
{
break;
}
}
FileReference OldResponseFile = new FileReference(Arguments[ResponseFileIdx].Substring(1));
FileReference NewResponseFile = new FileReference(OldResponseFile.FullName + ".lc");
const string OutputFilePrefix = "/Fo";
string[] ResponseLines = FileReference.ReadAllLines(OldResponseFile);
for (int Idx = 0; Idx < ResponseLines.Length; Idx++)
{
string ResponseLine = ResponseLines[Idx];
if (ResponseLine.StartsWith(OutputFilePrefix, StringComparison.Ordinal))
{
FileReference OldOutputFile = new FileReference(ResponseLine.Substring(3).Trim('\"'));
FileItem OldOutputFileItem = Action.ProducedItems.First(x => x.Location == OldOutputFile);
Action.ProducedItems.Remove(OldOutputFileItem);
FileReference NewOutputFile = OldOutputFile.ChangeExtension(".lc.obj");
FileItem NewOutputFileItem = FileItem.GetItemByFileReference(NewOutputFile);
Action.ProducedItems.Add(NewOutputFileItem);
OriginalFileToPatchedFile[OldOutputFile] = NewOutputFile;
ResponseLines[Idx] = OutputFilePrefix + "\"" + NewOutputFile.FullName + "\"";
break;
}
}
FileReference.WriteAllLines(NewResponseFile, ResponseLines);
Arguments[ResponseFileIdx] = "@" + NewResponseFile.FullName;
// Update the final arguments
Action.CommandArguments = Utils.FormatCommandLine(Arguments);
}
}
}
private LinkEnvironment SetupBinaryLinkEnvironment(ReadOnlyTargetRules Target, UEToolChain ToolChain, LinkEnvironment LinkEnvironment, CppCompileEnvironment CompileEnvironment, List <PrecompiledHeaderTemplate> SharedPCHs, ISourceFileWorkingSet WorkingSet, ActionGraph ActionGraph)
{
LinkEnvironment BinaryLinkEnvironment = new LinkEnvironment(LinkEnvironment);
HashSet <UEBuildModule> LinkEnvironmentVisitedModules = new HashSet <UEBuildModule>();
List <UEBuildBinary> BinaryDependencies = new List <UEBuildBinary>();
CppCompileEnvironment BinaryCompileEnvironment = CreateBinaryCompileEnvironment(CompileEnvironment);
foreach (UEBuildModule Module in Modules)
{
List <FileItem> LinkInputFiles;
if (Module.Binary == null || Module.Binary == this)
{
// Compile each module.
Log.TraceVerbose("Compile module: " + Module.Name);
LinkInputFiles = Module.Compile(Target, ToolChain, BinaryCompileEnvironment, SharedPCHs, WorkingSet, ActionGraph);
// NOTE: Because of 'Shared PCHs', in monolithic builds the same PCH file may appear as a link input
// multiple times for a single binary. We'll check for that here, and only add it once. This avoids
// a linker warning about redundant .obj files.
foreach (FileItem LinkInputFile in LinkInputFiles)
{
if (!BinaryLinkEnvironment.InputFiles.Contains(LinkInputFile))
{
BinaryLinkEnvironment.InputFiles.Add(LinkInputFile);
}
}
}
else
{
BinaryDependencies.Add(Module.Binary);
}
// Allow the module to modify the link environment for the binary.
Module.SetupPrivateLinkEnvironment(this, BinaryLinkEnvironment, BinaryDependencies, LinkEnvironmentVisitedModules);
}
// Allow the binary dependencies to modify the link environment.
foreach (UEBuildBinary BinaryDependency in BinaryDependencies)
{
BinaryDependency.SetupDependentLinkEnvironment(BinaryLinkEnvironment);
}
// Remove the default resource file on Windows (PCLaunch.rc) if the user has specified their own
if (BinaryLinkEnvironment.InputFiles.Select(Item => Path.GetFileName(Item.AbsolutePath).ToLower()).Any(Name => Name.EndsWith(".res") && !Name.EndsWith(".inl.res") && Name != "pclaunch.rc.res"))
{
BinaryLinkEnvironment.InputFiles.RemoveAll(x => Path.GetFileName(x.AbsolutePath).ToLower() == "pclaunch.rc.res");
}
// Set the link output file.
BinaryLinkEnvironment.OutputFilePaths = OutputFilePaths.ToList();
// Set whether the link is allowed to have exports.
BinaryLinkEnvironment.bHasExports = bAllowExports;
// Set the output folder for intermediate files
BinaryLinkEnvironment.IntermediateDirectory = IntermediateDirectory;
// Put the non-executable output files (PDB, import library, etc) in the same directory as the production
BinaryLinkEnvironment.OutputDirectory = OutputFilePaths[0].Directory;
// Setup link output type
BinaryLinkEnvironment.bIsBuildingDLL = IsBuildingDll(Type);
BinaryLinkEnvironment.bIsBuildingLibrary = IsBuildingLibrary(Type);
// If we don't have any resource file, use the default or compile a custom one for this module
if (BinaryLinkEnvironment.Platform == CppPlatform.Win32 || BinaryLinkEnvironment.Platform == CppPlatform.Win64)
{
if (!BinaryLinkEnvironment.InputFiles.Any(x => x.Location.HasExtension(".res")))
{
if (BinaryLinkEnvironment.DefaultResourceFiles.Count > 0)
{
// Use the default resource file if possible
BinaryLinkEnvironment.InputFiles.AddRange(BinaryLinkEnvironment.DefaultResourceFiles);
}
else
{
// Create a compile environment for resource files
CppCompileEnvironment ResourceCompileEnvironment = new CppCompileEnvironment(BinaryCompileEnvironment);
// @todo: This should be in some Windows code somewhere...
// Set the original file name macro; used in PCLaunch.rc to set the binary metadata fields.
string OriginalFilename = (OriginalOutputFilePaths != null) ? OriginalOutputFilePaths[0].GetFileName() : OutputFilePaths[0].GetFileName();
ResourceCompileEnvironment.Definitions.Add("ORIGINAL_FILE_NAME=\"" + OriginalFilename + "\"");
// Set the other version fields
ResourceCompileEnvironment.Definitions.Add(String.Format("BUILT_FROM_CHANGELIST={0}", Target.Version.Changelist));
ResourceCompileEnvironment.Definitions.Add(String.Format("BUILD_VERSION={0}", Target.BuildVersion));
// Otherwise compile the default resource file per-binary, so that it gets the correct ORIGINAL_FILE_NAME macro.
FileItem DefaultResourceFile = FileItem.GetItemByFileReference(FileReference.Combine(UnrealBuildTool.EngineSourceDirectory, "Runtime", "Launch", "Resources", "Windows", "PCLaunch.rc"));
CPPOutput DefaultResourceOutput = ToolChain.CompileRCFiles(BinaryCompileEnvironment, new List <FileItem> {
DefaultResourceFile
}, ((UEBuildModuleCPP)Modules.First()).IntermediateDirectory, ActionGraph);
BinaryLinkEnvironment.InputFiles.AddRange(DefaultResourceOutput.ObjectFiles);
}
}
}
// Add all the common resource files
BinaryLinkEnvironment.InputFiles.AddRange(BinaryLinkEnvironment.CommonResourceFiles);
return(BinaryLinkEnvironment);
}
/// <summary>
/// Checks if the makefile is valid for the current set of source files. This is done separately to the Load() method to allow pre-build steps to modify source files.
/// </summary>
/// <param name="Makefile">The makefile that has been loaded</param>
/// <param name="ProjectFile">Path to the project file</param>
/// <param name="WorkingSet">The current working set of source files</param>
/// <param name="ReasonNotLoaded">If the makefile is not valid, is set to a message describing why</param>
/// <returns>True if the makefile is valid, false otherwise</returns>
public static bool IsValidForSourceFiles(TargetMakefile Makefile, FileReference ProjectFile, ISourceFileWorkingSet WorkingSet, out string ReasonNotLoaded)
{
using (Timeline.ScopeEvent("TargetMakefile.IsValidForSourceFiles()"))
{
// Check if any source files have been added or removed
foreach (KeyValuePair <DirectoryItem, FileItem[]> Pair in Makefile.DirectoryToSourceFiles)
{
DirectoryItem InputDirectory = Pair.Key;
if (!InputDirectory.Exists || InputDirectory.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
FileItem[] SourceFiles = UEBuildModuleCPP.GetSourceFiles(InputDirectory);
if (SourceFiles.Length < Pair.Value.Length)
{
ReasonNotLoaded = "source file removed";
return(false);
}
else if (SourceFiles.Length > Pair.Value.Length)
{
ReasonNotLoaded = "source file added";
return(false);
}
else if (SourceFiles.Intersect(Pair.Value).Count() != SourceFiles.Length)
{
ReasonNotLoaded = "source file modified";
return(false);
}
}
}
// Check if any of the additional dependencies has changed
foreach (FileItem AdditionalDependency in Makefile.AdditionalDependencies)
{
if (!AdditionalDependency.Exists)
{
Log.TraceLog("{0} has been deleted since makefile was built.", AdditionalDependency.Location);
ReasonNotLoaded = string.Format("{0} deleted", AdditionalDependency.Location.GetFileName());
return(false);
}
if (AdditionalDependency.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
Log.TraceLog("{0} has been modified since makefile was built.", AdditionalDependency.Location);
ReasonNotLoaded = string.Format("{0} modified", AdditionalDependency.Location.GetFileName());
return(false);
}
}
// Check that no new plugins have been added
foreach (FileReference PluginFile in Plugins.EnumeratePlugins(ProjectFile))
{
FileItem PluginFileItem = FileItem.GetItemByFileReference(PluginFile);
if (!Makefile.PluginFiles.Contains(PluginFileItem))
{
Log.TraceLog("{0} has been added", PluginFile.GetFileName());
ReasonNotLoaded = string.Format("{0} has been added", PluginFile.GetFileName());
return(false);
}
}
// We do a check to see if any modules' headers have changed which have
// acquired or lost UHT types. If so, which should be rare,
// we'll just invalidate the entire makefile and force it to be rebuilt.
// Get all H files in processed modules newer than the makefile itself
HashSet <FileItem> HFilesNewerThanMakefile = new HashSet <FileItem>();
foreach (UHTModuleHeaderInfo ModuleHeaderInfo in Makefile.UObjectModuleHeaders)
{
foreach (FileItem HeaderFile in ModuleHeaderInfo.SourceFolder.EnumerateFiles())
{
if (HeaderFile.HasExtension(".h") && HeaderFile.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
HFilesNewerThanMakefile.Add(HeaderFile);
}
}
}
// Get all H files in all modules processed in the last makefile build
HashSet <FileItem> AllUHTHeaders = new HashSet <FileItem>(Makefile.UObjectModuleHeaders.SelectMany(x => x.HeaderFiles));
// Check whether any headers have been deleted. If they have, we need to regenerate the makefile since the module might now be empty. If we don't,
// and the file has been moved to a different module, we may include stale generated headers.
foreach (FileItem HeaderFile in AllUHTHeaders)
{
if (!HeaderFile.Exists)
{
Log.TraceLog("File processed by UHT was deleted ({0}); invalidating makefile", HeaderFile);
ReasonNotLoaded = string.Format("UHT file was deleted");
return(false);
}
}
// Makefile is invalid if:
// * There are any newer files which contain no UHT data, but were previously in the makefile
// * There are any newer files contain data which needs processing by UHT, but weren't not previously in the makefile
SourceFileMetadataCache MetadataCache = SourceFileMetadataCache.CreateHierarchy(ProjectFile);
foreach (FileItem HeaderFile in HFilesNewerThanMakefile)
{
bool bContainsUHTData = MetadataCache.ContainsReflectionMarkup(HeaderFile);
bool bWasProcessed = AllUHTHeaders.Contains(HeaderFile);
if (bContainsUHTData != bWasProcessed)
{
Log.TraceLog("{0} {1} contain UHT types and now {2} , ignoring it", HeaderFile, bWasProcessed ? "used to" : "didn't", bWasProcessed ? "doesn't" : "does");
ReasonNotLoaded = string.Format("new files with reflected types");
return(false);
}
}
// If adaptive unity build is enabled, do a check to see if there are any source files that became part of the
// working set since the Makefile was created (or, source files were removed from the working set.) If anything
// changed, then we'll force a new Makefile to be created so that we have fresh unity build blobs. We always
// want to make sure that source files in the working set are excluded from those unity blobs (for fastest possible
// iteration times.)
// Check if any source files in the working set no longer belong in it
foreach (FileItem SourceFile in Makefile.WorkingSet)
{
if (!WorkingSet.Contains(SourceFile) && SourceFile.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
Log.TraceLog("{0} was part of source working set and now is not; invalidating makefile", SourceFile.AbsolutePath);
ReasonNotLoaded = string.Format("working set of source files changed");
return(false);
}
}
// Check if any source files that are eligible for being in the working set have been modified
foreach (FileItem SourceFile in Makefile.CandidatesForWorkingSet)
{
if (WorkingSet.Contains(SourceFile) && SourceFile.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
Log.TraceLog("{0} was part of source working set and now is not", SourceFile.AbsolutePath);
ReasonNotLoaded = string.Format("working set of source files changed");
return(false);
}
}
}
ReasonNotLoaded = null;
return(true);
}
/// <summary>
/// Checks if the makefile is valid for the current set of source files. This is done separately to the Load() method to allow pre-build steps to modify source files.
/// </summary>
/// <param name="Makefile">The makefile that has been loaded</param>
/// <param name="ProjectFile">Path to the project file</param>
/// <param name="Platform">The platform being built</param>
/// <param name="WorkingSet">The current working set of source files</param>
/// <param name="ReasonNotLoaded">If the makefile is not valid, is set to a message describing why</param>
/// <returns>True if the makefile is valid, false otherwise</returns>
public static bool IsValidForSourceFiles(TargetMakefile Makefile, FileReference ProjectFile, UnrealTargetPlatform Platform, ISourceFileWorkingSet WorkingSet, out string ReasonNotLoaded)
{
using (Timeline.ScopeEvent("TargetMakefile.IsValidForSourceFiles()"))
{
// Get the list of excluded folder names for this platform
ReadOnlyHashSet <string> ExcludedFolderNames = UEBuildPlatform.GetBuildPlatform(Platform).GetExcludedFolderNames();
// Check if any source files have been added or removed
foreach (KeyValuePair <DirectoryItem, FileItem[]> Pair in Makefile.DirectoryToSourceFiles)
{
DirectoryItem InputDirectory = Pair.Key;
if (!InputDirectory.Exists || InputDirectory.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
FileItem[] SourceFiles = UEBuildModuleCPP.GetSourceFiles(InputDirectory);
if (SourceFiles.Length < Pair.Value.Length)
{
ReasonNotLoaded = "source file removed";
return(false);
}
else if (SourceFiles.Length > Pair.Value.Length)
{
ReasonNotLoaded = "source file added";
return(false);
}
else if (SourceFiles.Intersect(Pair.Value).Count() != SourceFiles.Length)
{
ReasonNotLoaded = "source file modified";
return(false);
}
foreach (DirectoryItem Directory in InputDirectory.EnumerateDirectories())
{
if (!Makefile.DirectoryToSourceFiles.ContainsKey(Directory) && ContainsSourceFiles(Directory, ExcludedFolderNames))
{
ReasonNotLoaded = "directory added";
return(false);
}
}
}
}
// Check if any external dependencies have changed. These comparisons are done against the makefile creation time.
foreach (FileItem ExternalDependency in Makefile.ExternalDependencies)
{
if (!ExternalDependency.Exists)
{
Log.TraceLog("{0} has been deleted since makefile was built.", ExternalDependency.Location);
ReasonNotLoaded = string.Format("{0} deleted", ExternalDependency.Location.GetFileName());
return(false);
}
if (ExternalDependency.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
Log.TraceLog("{0} has been modified since makefile was built.", ExternalDependency.Location);
ReasonNotLoaded = string.Format("{0} modified", ExternalDependency.Location.GetFileName());
return(false);
}
}
// Check if any internal dependencies has changed. These comparisons are done against the makefile modified time.
foreach (FileItem InternalDependency in Makefile.InternalDependencies)
{
if (!InternalDependency.Exists)
{
Log.TraceLog("{0} has been deleted since makefile was written.", InternalDependency.Location);
ReasonNotLoaded = string.Format("{0} deleted", InternalDependency.Location.GetFileName());
return(false);
}
if (InternalDependency.LastWriteTimeUtc > Makefile.ModifiedTimeUtc)
{
Log.TraceLog("{0} has been modified since makefile was written.", InternalDependency.Location);
ReasonNotLoaded = string.Format("{0} modified", InternalDependency.Location.GetFileName());
return(false);
}
}
// Check that no new plugins have been added
foreach (FileReference PluginFile in Plugins.EnumeratePlugins(ProjectFile))
{
FileItem PluginFileItem = FileItem.GetItemByFileReference(PluginFile);
if (!Makefile.PluginFiles.Contains(PluginFileItem))
{
Log.TraceLog("{0} has been added", PluginFile.GetFileName());
ReasonNotLoaded = string.Format("{0} has been added", PluginFile.GetFileName());
return(false);
}
}
// Load the metadata cache
SourceFileMetadataCache MetadataCache = SourceFileMetadataCache.CreateHierarchy(ProjectFile);
// Find the set of files that contain reflection markup
ConcurrentBag <FileItem> NewFilesWithMarkupBag = new ConcurrentBag <FileItem>();
using (ThreadPoolWorkQueue Queue = new ThreadPoolWorkQueue())
{
foreach (DirectoryItem SourceDirectory in Makefile.SourceDirectories)
{
Queue.Enqueue(() => FindFilesWithMarkup(SourceDirectory, MetadataCache, ExcludedFolderNames, NewFilesWithMarkupBag, Queue));
}
}
// Check whether the list has changed
List <FileItem> PrevFilesWithMarkup = Makefile.UObjectModuleHeaders.Where(x => !x.bUsePrecompiled).SelectMany(x => x.HeaderFiles).ToList();
List <FileItem> NextFilesWithMarkup = NewFilesWithMarkupBag.ToList();
if (NextFilesWithMarkup.Count != PrevFilesWithMarkup.Count || NextFilesWithMarkup.Intersect(PrevFilesWithMarkup).Count() != PrevFilesWithMarkup.Count)
{
ReasonNotLoaded = "UHT files changed";
return(false);
}
// If adaptive unity build is enabled, do a check to see if there are any source files that became part of the
// working set since the Makefile was created (or, source files were removed from the working set.) If anything
// changed, then we'll force a new Makefile to be created so that we have fresh unity build blobs. We always
// want to make sure that source files in the working set are excluded from those unity blobs (for fastest possible
// iteration times.)
// Check if any source files in the working set no longer belong in it
foreach (FileItem SourceFile in Makefile.WorkingSet)
{
if (!WorkingSet.Contains(SourceFile) && SourceFile.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
Log.TraceLog("{0} was part of source working set and now is not; invalidating makefile", SourceFile.AbsolutePath);
ReasonNotLoaded = string.Format("working set of source files changed");
return(false);
}
}
// Check if any source files that are eligible for being in the working set have been modified
foreach (FileItem SourceFile in Makefile.CandidatesForWorkingSet)
{
if (WorkingSet.Contains(SourceFile) && SourceFile.LastWriteTimeUtc > Makefile.CreateTimeUtc)
{
Log.TraceLog("{0} was part of source working set and now is not", SourceFile.AbsolutePath);
ReasonNotLoaded = string.Format("working set of source files changed");
return(false);
}
}
}
ReasonNotLoaded = null;
return(true);
}
static public bool FileExists(FileReference File)
{
return(FileItem.GetItemByFileReference(File).Exists);
}
public override FileItem LinkFiles(LinkEnvironment LinkEnvironment, bool bBuildImportLibraryOnly)
{
if (LinkEnvironment.Config.Target.Architecture == "-win32") // simulator
{
return(base.LinkFiles(LinkEnvironment, bBuildImportLibraryOnly));
}
FileItem OutputFile;
// Make the final javascript file
Action LinkAction = new Action(ActionType.Link);
// ResponseFile lines.
List <string> ReponseLines = new List <string>();
LinkAction.bCanExecuteRemotely = false;
LinkAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
LinkAction.CommandPath = HTML5SDKInfo.Python();
LinkAction.CommandArguments = HTML5SDKInfo.EmscriptenCompiler();
ReponseLines.Add(GetLinkArguments(LinkEnvironment));
// Add the input files to a response file, and pass the response file on the command-line.
foreach (FileItem InputFile in LinkEnvironment.InputFiles)
{
//System.Console.WriteLine("File {0} ", InputFile.AbsolutePath);
ReponseLines.Add(string.Format(" \"{0}\"", InputFile.AbsolutePath));
LinkAction.PrerequisiteItems.Add(InputFile);
}
if (!LinkEnvironment.Config.bIsBuildingLibrary)
{
// Make sure ThirdParty libs are at the end.
List <string> ThirdParty = (from Lib in LinkEnvironment.Config.AdditionalLibraries
where Lib.Contains("ThirdParty")
select Lib).ToList();
LinkEnvironment.Config.AdditionalLibraries.RemoveAll(Element => Element.Contains("ThirdParty"));
LinkEnvironment.Config.AdditionalLibraries.AddRange(ThirdParty);
foreach (string InputFile in LinkEnvironment.Config.AdditionalLibraries)
{
FileItem Item = FileItem.GetItemByPath(InputFile);
if (Item.AbsolutePath.Contains(".lib"))
{
continue;
}
if (Item != null)
{
if (Item.ToString().Contains(".js"))
{
ReponseLines.Add(string.Format(" --js-library \"{0}\"", Item.AbsolutePath));
}
else
{
ReponseLines.Add(string.Format(" \"{0}\"", Item.AbsolutePath));
}
LinkAction.PrerequisiteItems.Add(Item);
}
}
}
// make the file we will create
OutputFile = FileItem.GetItemByFileReference(LinkEnvironment.Config.OutputFilePath);
LinkAction.ProducedItems.Add(OutputFile);
ReponseLines.Add(string.Format(" -o \"{0}\"", OutputFile.AbsolutePath));
FileItem OutputBC = FileItem.GetItemByPath(LinkEnvironment.Config.OutputFilePath.FullName.Replace(".js", ".bc").Replace(".html", ".bc"));
LinkAction.ProducedItems.Add(OutputBC);
ReponseLines.Add(" --emit-symbol-map " + string.Format(" --save-bc \"{0}\"", OutputBC.AbsolutePath));
LinkAction.StatusDescription = Path.GetFileName(OutputFile.AbsolutePath);
FileReference ResponseFileName = GetResponseFileName(LinkEnvironment, OutputFile);
LinkAction.CommandArguments += string.Format(" @\"{0}\"", ResponseFile.Create(ResponseFileName, ReponseLines));
LinkAction.OutputEventHandler = new DataReceivedEventHandler(RemoteOutputReceivedEventHandler);
return(OutputFile);
}
public override CPPOutput CompileCPPFiles(UEBuildTarget Target, CPPEnvironment CompileEnvironment, List <FileItem> SourceFiles, string ModuleName)
{
if (CompileEnvironment.Config.Target.Architecture == "-win32") // simulator
{
return(base.CompileCPPFiles(Target, CompileEnvironment, SourceFiles, ModuleName));
}
string Arguments = GetCLArguments_Global(CompileEnvironment);
CPPOutput Result = new CPPOutput();
// Add include paths to the argument list.
foreach (string IncludePath in CompileEnvironment.Config.CPPIncludeInfo.IncludePaths)
{
Arguments += string.Format(" -I\"{0}\"", IncludePath);
}
foreach (string IncludePath in CompileEnvironment.Config.CPPIncludeInfo.SystemIncludePaths)
{
Arguments += string.Format(" -I\"{0}\"", IncludePath);
}
// Add preprocessor definitions to the argument list.
foreach (string Definition in CompileEnvironment.Config.Definitions)
{
Arguments += string.Format(" -D{0}", Definition);
}
if (bEnableTracing)
{
Arguments += string.Format(" -D__EMSCRIPTEN_TRACING__");
}
var BuildPlatform = UEBuildPlatform.GetBuildPlatformForCPPTargetPlatform(CompileEnvironment.Config.Target.Platform);
foreach (FileItem SourceFile in SourceFiles)
{
Action CompileAction = new Action(ActionType.Compile);
bool bIsPlainCFile = Path.GetExtension(SourceFile.AbsolutePath).ToUpperInvariant() == ".C";
// Add the C++ source file and its included files to the prerequisite item list.
AddPrerequisiteSourceFile(Target, BuildPlatform, CompileEnvironment, SourceFile, CompileAction.PrerequisiteItems);
// Add the source file path to the command-line.
string FileArguments = string.Format(" \"{0}\"", SourceFile.AbsolutePath);
var ObjectFileExtension = UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.HTML5).GetBinaryExtension(UEBuildBinaryType.Object);
// Add the object file to the produced item list.
FileItem ObjectFile = FileItem.GetItemByFileReference(
FileReference.Combine(
CompileEnvironment.Config.OutputDirectory,
Path.GetFileName(SourceFile.AbsolutePath) + ObjectFileExtension
)
);
CompileAction.ProducedItems.Add(ObjectFile);
FileArguments += string.Format(" -o \"{0}\"", ObjectFile.AbsolutePath);
// Add C or C++ specific compiler arguments.
if (bIsPlainCFile)
{
FileArguments += GetCLArguments_C(CompileEnvironment.Config.Target.Architecture);
}
else
{
FileArguments += GetCLArguments_CPP(CompileEnvironment);
}
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
CompileAction.CommandPath = HTML5SDKInfo.Python();
CompileAction.CommandArguments = HTML5SDKInfo.EmscriptenCompiler() + " " + Arguments + FileArguments + CompileEnvironment.Config.AdditionalArguments;
//System.Console.WriteLine(CompileAction.CommandArguments);
CompileAction.StatusDescription = Path.GetFileName(SourceFile.AbsolutePath);
CompileAction.OutputEventHandler = new DataReceivedEventHandler(CompileOutputReceivedDataEventHandler);
// Don't farm out creation of precomputed headers as it is the critical path task.
CompileAction.bCanExecuteRemotely = CompileEnvironment.Config.PrecompiledHeaderAction != PrecompiledHeaderAction.Create;
// this is the final output of the compile step (a .abc file)
Result.ObjectFiles.Add(ObjectFile);
// VC++ always outputs the source file name being compiled, so we don't need to emit this ourselves
CompileAction.bShouldOutputStatusDescription = true;
// Don't farm out creation of precompiled headers as it is the critical path task.
CompileAction.bCanExecuteRemotely =
CompileEnvironment.Config.PrecompiledHeaderAction != PrecompiledHeaderAction.Create ||
BuildConfiguration.bAllowRemotelyCompiledPCHs;
}
return(Result);
}
/// <summary>
/// Read a file item from a binary archive
/// </summary>
/// <param name="Reader">Reader to serialize data from</param>
/// <returns>Instance of the serialized file item</returns>
public static FileItem ReadFileItem(this BinaryArchiveReader Reader)
{
return(Reader.ReadObjectReference <FileItem>(() => FileItem.GetItemByFileReference(Reader.ReadFileReference())));
}
/// <summary>
/// Sets up the environment for compiling any module that includes the public interface of this module.
/// </summary>
public virtual void AddModuleToCompileEnvironment(
UEBuildBinary SourceBinary,
HashSet <DirectoryReference> IncludePaths,
HashSet <DirectoryReference> SystemIncludePaths,
List <string> Definitions,
List <UEBuildFramework> AdditionalFrameworks,
List <FileItem> AdditionalPrerequisites,
bool bLegacyPublicIncludePaths
)
{
// Add the module's parent directory to the include path, so we can root #includes from generated source files to it
IncludePaths.Add(ModuleDirectory.ParentDirectory);
// Add this module's public include paths and definitions.
AddIncludePaths(IncludePaths, PublicIncludePaths);
if (bLegacyPublicIncludePaths)
{
AddIncludePaths(IncludePaths, LegacyPublicIncludePaths);
}
SystemIncludePaths.UnionWith(PublicSystemIncludePaths);
Definitions.AddRange(PublicDefinitions);
// Add the import or export declaration for the module
if (Rules.Type == ModuleRules.ModuleType.CPlusPlus)
{
if (Rules.Target.LinkType == TargetLinkType.Monolithic)
{
if (Rules.Target.bShouldCompileAsDLL && (Rules.Target.bHasExports || Rules.ModuleSymbolVisibility == ModuleRules.SymbolVisibility.VisibileForDll))
{
Definitions.Add(ModuleApiDefine + "=DLLEXPORT");
}
else
{
Definitions.Add(ModuleApiDefine + "=");
}
}
else if (Binary == null || SourceBinary != Binary)
{
Definitions.Add(ModuleApiDefine + "=DLLIMPORT");
}
else if (!Binary.bAllowExports)
{
Definitions.Add(ModuleApiDefine + "=");
}
else
{
Definitions.Add(ModuleApiDefine + "=DLLEXPORT");
}
}
// Add the additional frameworks so that the compiler can know about their #include paths
AdditionalFrameworks.AddRange(PublicAdditionalFrameworks);
// Add any generated type library headers
if (Rules.TypeLibraries.Count > 0)
{
IncludePaths.Add(IntermediateDirectory);
foreach (ModuleRules.TypeLibrary TypeLibrary in Rules.TypeLibraries)
{
AdditionalPrerequisites.Add(FileItem.GetItemByFileReference(FileReference.Combine(IntermediateDirectory, TypeLibrary.Header)));
}
}
}
public override CPPOutput CompileISPCFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, IActionGraphBuilder Graph)
{
CPPOutput Result = new CPPOutput();
if (!CompileEnvironment.bCompileISPC)
{
return(Result);
}
List <string> CompileTargets = GetISPCCompileTargets(CompileEnvironment.Platform, null);
foreach (FileItem ISPCFile in InputFiles)
{
Action CompileAction = Graph.CreateAction(ActionType.Compile);
CompileAction.CommandDescription = "Compile";
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory;
CompileAction.CommandPath = new FileReference(GetISPCHostCompilerPath(BuildHostPlatform.Current.Platform));
CompileAction.StatusDescription = Path.GetFileName(ISPCFile.AbsolutePath);
// Disable remote execution to workaround mismatched case on XGE
CompileAction.bCanExecuteRemotely = false;
List <string> Arguments = new List <string>();
// Add the ISPC file to be compiled.
Arguments.Add(String.Format(" \"{0}\"", ISPCFile.AbsolutePath));
List <FileItem> CompiledISPCObjFiles = new List <FileItem>();
string TargetString = "";
foreach (string Target in CompileTargets)
{
string ObjTarget = Target;
if (Target.Contains("-"))
{
// Remove lane width and gang size from obj file name
ObjTarget = Target.Split('-')[0];
}
FileItem CompiledISPCObjFile;
if (CompileTargets.Count > 1)
{
CompiledISPCObjFile = FileItem.GetItemByFileReference(
FileReference.Combine(
OutputDir,
Path.GetFileName(ISPCFile.AbsolutePath) + "_" + ObjTarget + GetISPCObjectFileSuffix(CompileEnvironment.Platform)
)
);
}
else
{
CompiledISPCObjFile = FileItem.GetItemByFileReference(
FileReference.Combine(
OutputDir,
Path.GetFileName(ISPCFile.AbsolutePath) + GetISPCObjectFileSuffix(CompileEnvironment.Platform)
)
);
}
// Add the ISA specific ISPC obj files to the produced item list.
CompiledISPCObjFiles.Add(CompiledISPCObjFile);
// Build target string. No comma on last
if (Target == CompileTargets[CompileTargets.Count - 1]) // .Last()
{
TargetString += Target;
}
else
{
TargetString += Target + ",";
}
}
// Add the common ISPC obj file to the produced item list.
FileItem CompiledISPCObjFileNoISA = FileItem.GetItemByFileReference(
FileReference.Combine(
OutputDir,
Path.GetFileName(ISPCFile.AbsolutePath) + GetISPCObjectFileSuffix(CompileEnvironment.Platform)
)
);
CompiledISPCObjFiles.Add(CompiledISPCObjFileNoISA);
// Add the output ISPC obj file
Arguments.Add(String.Format("-o \"{0}\"", CompiledISPCObjFileNoISA));
// Build target triplet
Arguments.Add(String.Format("--target-os=\"{0}\"", GetISPCOSTarget(CompileEnvironment.Platform)));
Arguments.Add(String.Format("--arch=\"{0}\"", GetISPCArchTarget(CompileEnvironment.Platform, null)));
Arguments.Add(String.Format("--target=\"{0}\"", TargetString));
if (CompileEnvironment.Configuration == CppConfiguration.Debug)
{
Arguments.Add("-g -O0");
}
else
{
Arguments.Add("-O2");
}
// PIC is needed for modular builds except on Windows
if ((CompileEnvironment.bIsBuildingDLL ||
CompileEnvironment.bIsBuildingLibrary) &&
!UEBuildPlatform.IsPlatformInGroup(CompileEnvironment.Platform, UnrealPlatformGroup.Windows))
{
Arguments.Add("--pic");
}
// Include paths. Don't use AddIncludePath() here, since it uses the full path and exceeds the max command line length.
foreach (DirectoryReference IncludePath in CompileEnvironment.UserIncludePaths)
{
Arguments.Add(String.Format("-I\"{0}\"", IncludePath));
}
// System include paths.
foreach (DirectoryReference SystemIncludePath in CompileEnvironment.SystemIncludePaths)
{
Arguments.Add(String.Format("-I\"{0}\"", SystemIncludePath));
}
// Preprocessor definitions.
foreach (string Definition in CompileEnvironment.Definitions)
{
Arguments.Add(String.Format("-D\"{0}\"", Definition));
}
// Consume the included header dependency list
if (CompileEnvironment.bGenerateDependenciesFile)
{
FileItem DependencyListFile = FileItem.GetItemByFileReference(FileReference.Combine(OutputDir, Path.GetFileName(ISPCFile.AbsolutePath) + ".txt"));
CompileAction.DependencyListFile = DependencyListFile;
CompileAction.PrerequisiteItems.Add(DependencyListFile);
}
CompileAction.ProducedItems.AddRange(CompiledISPCObjFiles);
Result.ObjectFiles.AddRange(CompiledISPCObjFiles);
FileReference ResponseFileName = new FileReference(CompiledISPCObjFileNoISA.AbsolutePath + ".response");
FileItem ResponseFileItem = Graph.CreateIntermediateTextFile(ResponseFileName, Arguments.Select(x => Utils.ExpandVariables(x)));
CompileAction.CommandArguments = " @\"" + ResponseFileName + "\"";
CompileAction.PrerequisiteItems.Add(ResponseFileItem);
// Add the source file and its included files to the prerequisite item list.
CompileAction.PrerequisiteItems.Add(ISPCFile);
Log.TraceVerbose(" ISPC Compiling " + CompileAction.StatusDescription + ": \"" + CompileAction.CommandPath + "\"" + CompileAction.CommandArguments);
}
return(Result);
}
/// <summary>
/// Determines all the actions that should be executed for a target (filtering for single module/file, etc..)
/// </summary>
/// <param name="TargetDescriptor">The target being built</param>
/// <param name="Makefile">Makefile for the target</param>
/// <param name="OutputItems">Set of all output items</param>
/// <returns>List of actions that need to be executed</returns>
static void GatherOutputItems(TargetDescriptor TargetDescriptor, TargetMakefile Makefile, HashSet <FileItem> OutputItems)
{
if (TargetDescriptor.SpecificFilesToCompile.Count > 0)
{
// If we're just compiling a specific files, set the target items to be all the derived items
List <FileItem> FilesToCompile = TargetDescriptor.SpecificFilesToCompile.ConvertAll(x => FileItem.GetItemByFileReference(x));
OutputItems.UnionWith(
Makefile.Actions.Where(x => x.PrerequisiteItems.Any(y => FilesToCompile.Contains(y)))
.SelectMany(x => x.ProducedItems));
}
else if (TargetDescriptor.OnlyModuleNames.Count > 0)
{
// Find the output items for this module
foreach (string OnlyModuleName in TargetDescriptor.OnlyModuleNames)
{
FileItem[] OutputItemsForModule;
if (!Makefile.ModuleNameToOutputItems.TryGetValue(OnlyModuleName, out OutputItemsForModule))
{
throw new BuildException("Unable to find output items for module '{0}'", OnlyModuleName);
}
OutputItems.UnionWith(OutputItemsForModule);
}
}
else
{
// Use all the output items from the target
OutputItems.UnionWith(Makefile.OutputItems);
}
}
private LinkEnvironment SetupBinaryLinkEnvironment(UEBuildTarget Target, UEToolChain ToolChain, LinkEnvironment LinkEnvironment, CPPEnvironment CompileEnvironment, List <PrecompiledHeaderTemplate> SharedPCHs, ActionGraph ActionGraph)
{
LinkEnvironment BinaryLinkEnvironment = LinkEnvironment.DeepCopy();
HashSet <UEBuildModule> LinkEnvironmentVisitedModules = new HashSet <UEBuildModule>();
List <UEBuildBinary> BinaryDependencies = new List <UEBuildBinary>();
CompileEnvironment.Config.bIsBuildingDLL = IsBuildingDll(Config.Type);
CompileEnvironment.Config.bIsBuildingLibrary = IsBuildingLibrary(Config.Type);
CPPEnvironment BinaryCompileEnvironment = CompileEnvironment.DeepCopy();
// @Hack: This to prevent UHT from listing CoreUObject.generated.cpp as its dependency.
// We flag the compile environment when we build UHT so that we don't need to check
// this for each file when generating their dependencies.
BinaryCompileEnvironment.bHackHeaderGenerator = (Target.GetAppName() == "UnrealHeaderTool");
// @todo: This should be in some Windows code somewhere...
// Set the original file name macro; used in PCLaunch.rc to set the binary metadata fields.
string OriginalFilename = (Config.OriginalOutputFilePaths != null) ?
Config.OriginalOutputFilePaths[0].GetFileName() :
Config.OutputFilePaths[0].GetFileName();
BinaryCompileEnvironment.Config.Definitions.Add("ORIGINAL_FILE_NAME=\"" + OriginalFilename + "\"");
foreach (UEBuildModule Module in Modules)
{
List <FileItem> LinkInputFiles;
if (Module.Binary == null || Module.Binary == this)
{
// Compile each module.
Log.TraceVerbose("Compile module: " + Module.Name);
LinkInputFiles = Module.Compile(Target, ToolChain, BinaryCompileEnvironment, SharedPCHs, ActionGraph);
// NOTE: Because of 'Shared PCHs', in monolithic builds the same PCH file may appear as a link input
// multiple times for a single binary. We'll check for that here, and only add it once. This avoids
// a linker warning about redundant .obj files.
foreach (FileItem LinkInputFile in LinkInputFiles)
{
if (!BinaryLinkEnvironment.InputFiles.Contains(LinkInputFile))
{
BinaryLinkEnvironment.InputFiles.Add(LinkInputFile);
}
}
}
else
{
BinaryDependencies.Add(Module.Binary);
}
if (!BuildConfiguration.bRunUnrealCodeAnalyzer)
{
// Allow the module to modify the link environment for the binary.
Module.SetupPrivateLinkEnvironment(this, BinaryLinkEnvironment, BinaryDependencies, LinkEnvironmentVisitedModules);
}
}
// Allow the binary dependencies to modify the link environment.
foreach (UEBuildBinary BinaryDependency in BinaryDependencies)
{
BinaryDependency.SetupDependentLinkEnvironment(BinaryLinkEnvironment);
}
// Remove the default resource file on Windows (PCLaunch.rc) if the user has specified their own
if (BinaryLinkEnvironment.InputFiles.Select(Item => Path.GetFileName(Item.AbsolutePath).ToLower()).Any(Name => Name.EndsWith(".res") && !Name.EndsWith(".inl.res") && Name != "pclaunch.rc.res"))
{
BinaryLinkEnvironment.InputFiles.RemoveAll(x => Path.GetFileName(x.AbsolutePath).ToLower() == "pclaunch.rc.res");
}
// Set the link output file.
BinaryLinkEnvironment.Config.OutputFilePaths = Config.OutputFilePaths.ToList();
// Set whether the link is allowed to have exports.
BinaryLinkEnvironment.Config.bHasExports = Config.bAllowExports;
// Set the output folder for intermediate files
BinaryLinkEnvironment.Config.IntermediateDirectory = Config.IntermediateDirectory;
// Put the non-executable output files (PDB, import library, etc) in the same directory as the production
BinaryLinkEnvironment.Config.OutputDirectory = Config.OutputFilePaths[0].Directory;
// Setup link output type
BinaryLinkEnvironment.Config.bIsBuildingDLL = IsBuildingDll(Config.Type);
BinaryLinkEnvironment.Config.bIsBuildingLibrary = IsBuildingLibrary(Config.Type);
BinaryLinkEnvironment.Config.ProjectFile = Target.ProjectFile;
// Add the default resources for dlls
if (Config.Type == UEBuildBinaryType.DynamicLinkLibrary)
{
// Check if there's already a custom resource file
if (!BinaryLinkEnvironment.InputFiles.Any(x => x.Reference.HasExtension(".res")))
{
if (UEBuildConfiguration.bFormalBuild)
{
// For formal builds, compile the default resource file per-binary, so that it gets the correct ORIGINAL_FILE_NAME macro.
CPPEnvironment BinaryResourceCompileEnvironment = BinaryCompileEnvironment.DeepCopy();
BinaryResourceCompileEnvironment.Config.OutputDirectory = DirectoryReference.Combine(BinaryResourceCompileEnvironment.Config.OutputDirectory, Modules.First().Name);
FileItem DefaultResourceFile = FileItem.GetItemByFileReference(FileReference.Combine(UnrealBuildTool.EngineSourceDirectory, "Runtime", "Launch", "Resources", "Windows", "PCLaunch.rc"));
CPPOutput DefaultResourceOutput = ToolChain.CompileRCFiles(BinaryResourceCompileEnvironment, new List <FileItem> {
DefaultResourceFile
}, ActionGraph);
BinaryLinkEnvironment.InputFiles.AddRange(DefaultResourceOutput.ObjectFiles);
}
else
{
// For non-formal builds, we just want to share the default resource file between modules
BinaryLinkEnvironment.InputFiles.AddRange(BinaryLinkEnvironment.DefaultResourceFiles);
}
}
// Add all the common resource files
BinaryLinkEnvironment.InputFiles.AddRange(BinaryLinkEnvironment.CommonResourceFiles);
}
return(BinaryLinkEnvironment);
}
public override CPPOutput CompileCPPFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, string ModuleName, ActionGraph ActionGraph)
{
// Get the MSVC arguments required to compile all files in this batch
List <string> SharedArguments = new List <string>();
SharedArguments.Add("/nologo");
SharedArguments.Add("/P"); // Preprocess
SharedArguments.Add("/C"); // Preserve comments when preprocessing
SharedArguments.Add("/D PVS_STUDIO");
SharedArguments.Add("/wd4005");
if (EnvVars.Compiler >= WindowsCompiler.VisualStudio2015)
{
SharedArguments.Add("/D _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS=1");
}
foreach (DirectoryReference IncludePath in CompileEnvironment.IncludePaths.UserIncludePaths)
{
SharedArguments.Add(String.Format("/I \"{0}\"", IncludePath));
}
foreach (DirectoryReference IncludePath in CompileEnvironment.IncludePaths.SystemIncludePaths)
{
SharedArguments.Add(String.Format("/I \"{0}\"", IncludePath));
}
foreach (DirectoryReference IncludePath in EnvVars.IncludePaths)
{
SharedArguments.Add(String.Format("/I \"{0}\"", IncludePath));
}
foreach (string Definition in CompileEnvironment.Definitions)
{
SharedArguments.Add(String.Format("/D \"{0}\"", Definition));
}
foreach (FileItem ForceIncludeFile in CompileEnvironment.ForceIncludeFiles)
{
SharedArguments.Add(String.Format("/FI\"{0}\"", ForceIncludeFile.Location));
}
CPPOutput Result = new CPPOutput();
foreach (FileItem SourceFile in InputFiles)
{
// Get the file names for everything we need
string BaseFileName = SourceFile.Location.GetFileName();
// Write the response file
FileReference PreprocessedFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".i");
List <string> Arguments = new List <string>(SharedArguments);
Arguments.Add(String.Format("/Fi\"{0}\"", PreprocessedFileLocation)); // Preprocess to a file
Arguments.Add(String.Format("\"{0}\"", SourceFile.AbsolutePath));
FileReference ResponseFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".i.response");
FileItem ResponseFileItem = FileItem.CreateIntermediateTextFile(ResponseFileLocation, String.Join("\n", Arguments));
// Preprocess the source file
FileItem PreprocessedFileItem = FileItem.GetItemByFileReference(PreprocessedFileLocation);
Action PreprocessAction = ActionGraph.Add(ActionType.Compile);
PreprocessAction.CommandPath = EnvVars.CompilerPath.FullName;
PreprocessAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
PreprocessAction.CommandArguments = " @\"" + ResponseFileItem.AbsolutePath + "\"";
PreprocessAction.PrerequisiteItems.AddRange(CompileEnvironment.ForceIncludeFiles);
PreprocessAction.PrerequisiteItems.Add(SourceFile);
PreprocessAction.PrerequisiteItems.Add(ResponseFileItem);
PreprocessAction.ProducedItems.Add(PreprocessedFileItem);
PreprocessAction.bShouldOutputStatusDescription = false;
// Write the PVS studio config file
StringBuilder ConfigFileContents = new StringBuilder();
foreach (DirectoryReference IncludePath in EnvVars.IncludePaths)
{
ConfigFileContents.AppendFormat("exclude-path={0}\n", IncludePath.FullName);
}
foreach (string PathMask in ApplicationSettings.PathMasks)
{
if (PathMask.Contains(":") || PathMask.Contains("\\") || PathMask.Contains("/"))
{
if (Path.IsPathRooted(PathMask) && !PathMask.Contains(":"))
{
ConfigFileContents.AppendFormat("exclude-path=*{0}*\n", PathMask);
}
else
{
ConfigFileContents.AppendFormat("exclude-path={0}\n", PathMask);
}
}
}
if (CppPlatform == CppPlatform.Win64)
{
ConfigFileContents.Append("platform=x64\n");
}
else if (CppPlatform == CppPlatform.Win32)
{
ConfigFileContents.Append("platform=Win32\n");
}
else
{
throw new BuildException("PVS-Studio does not support this platform");
}
ConfigFileContents.Append("preprocessor=visualcpp\n");
ConfigFileContents.Append("language=C++\n");
ConfigFileContents.Append("skip-cl-exe=yes\n");
ConfigFileContents.AppendFormat("i-file={0}\n", PreprocessedFileItem.Location.FullName);
FileReference ConfigFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".cfg");
FileItem ConfigFileItem = FileItem.CreateIntermediateTextFile(ConfigFileLocation, ConfigFileContents.ToString());
// Run the analzyer on the preprocessed source file
FileReference OutputFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".pvslog");
FileItem OutputFileItem = FileItem.GetItemByFileReference(OutputFileLocation);
Action AnalyzeAction = ActionGraph.Add(ActionType.Compile);
AnalyzeAction.CommandDescription = "Analyzing";
AnalyzeAction.StatusDescription = BaseFileName;
AnalyzeAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
AnalyzeAction.CommandPath = AnalyzerFile.FullName;
AnalyzeAction.CommandArguments = String.Format("--cl-params \"{0}\" --source-file \"{1}\" --output-file \"{2}\" --cfg \"{3}\" --analysis-mode 4", PreprocessAction.CommandArguments, SourceFile.AbsolutePath, OutputFileLocation, ConfigFileItem.AbsolutePath);
if (LicenseFile != null)
{
AnalyzeAction.CommandArguments += String.Format(" --lic-file \"{0}\"", LicenseFile);
AnalyzeAction.PrerequisiteItems.Add(FileItem.GetItemByFileReference(LicenseFile));
}
AnalyzeAction.PrerequisiteItems.Add(ConfigFileItem);
AnalyzeAction.PrerequisiteItems.Add(PreprocessedFileItem);
AnalyzeAction.ProducedItems.Add(OutputFileItem);
AnalyzeAction.bShouldDeleteProducedItems = true; // PVS Studio will append by default, so need to delete produced items
Result.ObjectFiles.AddRange(AnalyzeAction.ProducedItems);
}
return(Result);
}
public override CPPOutput CompileCPPFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, string ModuleName, ActionGraph ActionGraph)
{
string Arguments = GetCLArguments_Global(CompileEnvironment);
CPPOutput Result = new CPPOutput();
// Add include paths to the argument list.
foreach (DirectoryReference IncludePath in CompileEnvironment.IncludePaths.UserIncludePaths)
{
AddIncludePath(ref Arguments, IncludePath);
}
foreach (DirectoryReference IncludePath in CompileEnvironment.IncludePaths.SystemIncludePaths)
{
AddIncludePath(ref Arguments, IncludePath);
}
// Add preprocessor definitions to the argument list.
foreach (string Definition in CompileEnvironment.Definitions)
{
Arguments += string.Format(" -D{0}", Definition);
}
if (bEnableTracing)
{
Arguments += string.Format(" -D__EMSCRIPTEN_TRACING__");
}
// Force include all the requested headers
foreach (FileItem ForceIncludeFile in CompileEnvironment.ForceIncludeFiles)
{
Arguments += String.Format(" -include \"{0}\"", ForceIncludeFile.Location);
}
foreach (FileItem SourceFile in InputFiles)
{
Action CompileAction = ActionGraph.Add(ActionType.Compile);
CompileAction.CommandDescription = "Compile";
CompileAction.PrerequisiteItems.AddRange(CompileEnvironment.ForceIncludeFiles);
// CompileAction.bPrintDebugInfo = true;
bool bIsPlainCFile = Path.GetExtension(SourceFile.AbsolutePath).ToUpperInvariant() == ".C";
// Add the C++ source file and its included files to the prerequisite item list.
AddPrerequisiteSourceFile(CompileEnvironment, SourceFile, CompileAction.PrerequisiteItems);
// Add the source file path to the command-line.
string FileArguments = string.Format(" \"{0}\"", SourceFile.AbsolutePath);
string ObjectFileExtension = UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.HTML5).GetBinaryExtension(UEBuildBinaryType.Object);
// Add the object file to the produced item list.
FileItem ObjectFile = FileItem.GetItemByFileReference(
FileReference.Combine(
OutputDir,
Path.GetFileName(SourceFile.AbsolutePath) + ObjectFileExtension
)
);
CompileAction.ProducedItems.Add(ObjectFile);
FileArguments += string.Format(" -o \"{0}\"", ObjectFile.AbsolutePath);
// Add C or C++ specific compiler arguments.
if (bIsPlainCFile)
{
FileArguments += GetCLArguments_C(CompileEnvironment.Architecture);
}
else
{
FileArguments += GetCLArguments_CPP(CompileEnvironment);
}
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
CompileAction.CommandPath = HTML5SDKInfo.Python();
CompileAction.CommandArguments = HTML5SDKInfo.EmscriptenCompiler() + " " + Arguments + FileArguments + CompileEnvironment.AdditionalArguments;
//System.Console.WriteLine(CompileAction.CommandArguments);
CompileAction.StatusDescription = Path.GetFileName(SourceFile.AbsolutePath);
// Don't farm out creation of precomputed headers as it is the critical path task.
CompileAction.bCanExecuteRemotely = CompileEnvironment.PrecompiledHeaderAction != PrecompiledHeaderAction.Create;
// this is the final output of the compile step (a .abc file)
Result.ObjectFiles.Add(ObjectFile);
// VC++ always outputs the source file name being compiled, so we don't need to emit this ourselves
CompileAction.bShouldOutputStatusDescription = true;
// Don't farm out creation of precompiled headers as it is the critical path task.
CompileAction.bCanExecuteRemotely =
CompileEnvironment.PrecompiledHeaderAction != PrecompiledHeaderAction.Create ||
CompileEnvironment.bAllowRemotelyCompiledPCHs;
}
return(Result);
}
/// <summary>
/// Patch the action graph for hot reloading, mapping files according to the given dictionary.
/// </summary>
public static void PatchActionGraph(IEnumerable <Action> Actions, Dictionary <FileReference, FileReference> OriginalFileToHotReloadFile)
{
// Gather all of the response files for link actions. We're going to need to patch 'em up after we figure out new
// names for all of the output files and import libraries
List <string> ResponseFilePaths = new List <string>();
// Same as Response files but for all of the link.sh files for link actions.
// Only used on BuildHostPlatform Linux
List <string> LinkScriptFilePaths = new List <string>();
// Keep a map of the original file names and their new file names, so we can fix up response files after
Dictionary <string, string> OriginalFileNameAndNewFileNameList_NoExtensions = new Dictionary <string, string>();
// Finally, we'll keep track of any file items that we had to create counterparts for change file names, so we can fix those up too
Dictionary <FileItem, FileItem> AffectedOriginalFileItemAndNewFileItemMap = new Dictionary <FileItem, FileItem>();
foreach (Action Action in Actions.Where((Action) => Action.ActionType == ActionType.Link))
{
// Assume that the first produced item (with no extension) is our output file name
FileReference HotReloadFile;
if (!OriginalFileToHotReloadFile.TryGetValue(Action.ProducedItems[0].Location, out HotReloadFile))
{
continue;
}
string OriginalFileNameWithoutExtension = Utils.GetFilenameWithoutAnyExtensions(Action.ProducedItems[0].AbsolutePath);
string NewFileNameWithoutExtension = Utils.GetFilenameWithoutAnyExtensions(HotReloadFile.FullName);
// Find the response file in the command line. We'll need to make a copy of it with our new file name.
string ResponseFileExtension = ".response";
int ResponseExtensionIndex = Action.CommandArguments.IndexOf(ResponseFileExtension, StringComparison.InvariantCultureIgnoreCase);
if (ResponseExtensionIndex != -1)
{
int ResponseFilePathIndex = Action.CommandArguments.LastIndexOf("@\"", ResponseExtensionIndex);
if (ResponseFilePathIndex == -1)
{
throw new BuildException("Couldn't find response file path in action's command arguments when hot reloading");
}
string OriginalResponseFilePathWithoutExtension = Action.CommandArguments.Substring(ResponseFilePathIndex + 2, (ResponseExtensionIndex - ResponseFilePathIndex) - 2);
string OriginalResponseFilePath = OriginalResponseFilePathWithoutExtension + ResponseFileExtension;
string NewResponseFilePath = ReplaceBaseFileName(OriginalResponseFilePath, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
// Copy the old response file to the new path
if (String.Compare(OriginalResponseFilePath, NewResponseFilePath, StringComparison.OrdinalIgnoreCase) != 0)
{
File.Copy(OriginalResponseFilePath, NewResponseFilePath, overwrite: true);
}
// Keep track of the new response file name. We'll have to do some edits afterwards.
ResponseFilePaths.Add(NewResponseFilePath);
}
// Find the *.link.sh file in the command line. We'll need to make a copy of it with our new file name.
// Only currently used on Linux
if (UEBuildPlatform.IsPlatformInGroup(BuildHostPlatform.Current.Platform, UnrealPlatformGroup.Unix))
{
string LinkScriptFileExtension = ".link.sh";
int LinkScriptExtensionIndex = Action.CommandArguments.IndexOf(LinkScriptFileExtension, StringComparison.InvariantCultureIgnoreCase);
if (LinkScriptExtensionIndex != -1)
{
// We expect the script invocation to be quoted
int LinkScriptFilePathIndex = Action.CommandArguments.LastIndexOf("\"", LinkScriptExtensionIndex);
if (LinkScriptFilePathIndex == -1)
{
throw new BuildException("Couldn't find link script file path in action's command arguments when hot reloading. Is the path quoted?");
}
string OriginalLinkScriptFilePathWithoutExtension = Action.CommandArguments.Substring(LinkScriptFilePathIndex + 1, (LinkScriptExtensionIndex - LinkScriptFilePathIndex) - 1);
string OriginalLinkScriptFilePath = OriginalLinkScriptFilePathWithoutExtension + LinkScriptFileExtension;
string NewLinkScriptFilePath = ReplaceBaseFileName(OriginalLinkScriptFilePath, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
// Copy the old response file to the new path
File.Copy(OriginalLinkScriptFilePath, NewLinkScriptFilePath, overwrite: true);
// Keep track of the new response file name. We'll have to do some edits afterwards.
LinkScriptFilePaths.Add(NewLinkScriptFilePath);
}
// Update this action's list of prerequisite items too
for (int ItemIndex = 0; ItemIndex < Action.PrerequisiteItems.Count; ++ItemIndex)
{
FileItem OriginalPrerequisiteItem = Action.PrerequisiteItems[ItemIndex];
string NewPrerequisiteItemFilePath = ReplaceBaseFileName(OriginalPrerequisiteItem.AbsolutePath, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
if (OriginalPrerequisiteItem.AbsolutePath != NewPrerequisiteItemFilePath)
{
// OK, the prerequisite item's file name changed so we'll update it to point to our new file
FileItem NewPrerequisiteItem = FileItem.GetItemByPath(NewPrerequisiteItemFilePath);
Action.PrerequisiteItems[ItemIndex] = NewPrerequisiteItem;
// Keep track of it so we can fix up dependencies in a second pass afterwards
AffectedOriginalFileItemAndNewFileItemMap.Add(OriginalPrerequisiteItem, NewPrerequisiteItem);
ResponseExtensionIndex = OriginalPrerequisiteItem.AbsolutePath.IndexOf(ResponseFileExtension, StringComparison.InvariantCultureIgnoreCase);
if (ResponseExtensionIndex != -1)
{
string OriginalResponseFilePathWithoutExtension = OriginalPrerequisiteItem.AbsolutePath.Substring(0, ResponseExtensionIndex);
string OriginalResponseFilePath = OriginalResponseFilePathWithoutExtension + ResponseFileExtension;
string NewResponseFilePath = ReplaceBaseFileName(OriginalResponseFilePath, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
// Copy the old response file to the new path
File.Copy(OriginalResponseFilePath, NewResponseFilePath, overwrite: true);
// Keep track of the new response file name. We'll have to do some edits afterwards.
ResponseFilePaths.Add(NewResponseFilePath);
}
}
}
}
// Update this action's list of produced items too
for (int ItemIndex = 0; ItemIndex < Action.ProducedItems.Count; ++ItemIndex)
{
FileItem OriginalProducedItem = Action.ProducedItems[ItemIndex];
string NewProducedItemFilePath = ReplaceBaseFileName(OriginalProducedItem.AbsolutePath, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
if (OriginalProducedItem.AbsolutePath != NewProducedItemFilePath)
{
// OK, the produced item's file name changed so we'll update it to point to our new file
FileItem NewProducedItem = FileItem.GetItemByPath(NewProducedItemFilePath);
Action.ProducedItems[ItemIndex] = NewProducedItem;
// Keep track of it so we can fix up dependencies in a second pass afterwards
AffectedOriginalFileItemAndNewFileItemMap.Add(OriginalProducedItem, NewProducedItem);
}
}
// Fix up the list of items to delete too
for (int Idx = 0; Idx < Action.DeleteItems.Count; Idx++)
{
FileItem NewItem;
if (AffectedOriginalFileItemAndNewFileItemMap.TryGetValue(Action.DeleteItems[Idx], out NewItem))
{
Action.DeleteItems[Idx] = NewItem;
}
}
// The status description of the item has the file name, so we'll update it too
Action.StatusDescription = ReplaceBaseFileName(Action.StatusDescription, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
// Keep track of the file names, so we can fix up response files afterwards.
if (!OriginalFileNameAndNewFileNameList_NoExtensions.ContainsKey(OriginalFileNameWithoutExtension))
{
OriginalFileNameAndNewFileNameList_NoExtensions[OriginalFileNameWithoutExtension] = NewFileNameWithoutExtension;
}
else if (OriginalFileNameAndNewFileNameList_NoExtensions[OriginalFileNameWithoutExtension] != NewFileNameWithoutExtension)
{
throw new BuildException("Unexpected conflict in renaming files; {0} maps to {1} and {2}", OriginalFileNameWithoutExtension, OriginalFileNameAndNewFileNameList_NoExtensions[OriginalFileNameWithoutExtension], NewFileNameWithoutExtension);
}
}
// Do another pass and update any actions that depended on the original file names that we changed
foreach (Action Action in Actions)
{
for (int ItemIndex = 0; ItemIndex < Action.PrerequisiteItems.Count; ++ItemIndex)
{
FileItem OriginalFileItem = Action.PrerequisiteItems[ItemIndex];
FileItem NewFileItem;
if (AffectedOriginalFileItemAndNewFileItemMap.TryGetValue(OriginalFileItem, out NewFileItem))
{
// OK, looks like we need to replace this file item because we've renamed the file
Action.PrerequisiteItems[ItemIndex] = NewFileItem;
}
}
}
if (OriginalFileNameAndNewFileNameList_NoExtensions.Count > 0)
{
// Update all the paths in link actions
foreach (Action Action in Actions.Where((Action) => Action.ActionType == ActionType.Link))
{
foreach (KeyValuePair <string, string> FileNameTuple in OriginalFileNameAndNewFileNameList_NoExtensions)
{
string OriginalFileNameWithoutExtension = FileNameTuple.Key;
string NewFileNameWithoutExtension = FileNameTuple.Value;
Action.CommandArguments = ReplaceBaseFileName(Action.CommandArguments, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
}
}
foreach (string ResponseFilePath in ResponseFilePaths)
{
// Load the file up
string FileContents = Utils.ReadAllText(ResponseFilePath);
// Replace all of the old file names with new ones
foreach (KeyValuePair <string, string> FileNameTuple in OriginalFileNameAndNewFileNameList_NoExtensions)
{
string OriginalFileNameWithoutExtension = FileNameTuple.Key;
string NewFileNameWithoutExtension = FileNameTuple.Value;
FileContents = ReplaceBaseFileName(FileContents, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
}
// Overwrite the original file
File.WriteAllText(ResponseFilePath, FileContents, new System.Text.UTF8Encoding(false));
}
if (UEBuildPlatform.IsPlatformInGroup(BuildHostPlatform.Current.Platform, UnrealPlatformGroup.Unix))
{
foreach (string LinkScriptFilePath in LinkScriptFilePaths)
{
// Load the file up
string FileContents = Utils.ReadAllText(LinkScriptFilePath);
// Replace all of the old file names with new ones
foreach (KeyValuePair <string, string> FileNameTuple in OriginalFileNameAndNewFileNameList_NoExtensions)
{
string OriginalFileNameWithoutExtension = FileNameTuple.Key;
string NewFileNameWithoutExtension = FileNameTuple.Value;
FileContents = ReplaceBaseFileName(FileContents, OriginalFileNameWithoutExtension, NewFileNameWithoutExtension);
}
// Overwrite the original file
File.WriteAllText(LinkScriptFilePath, FileContents, new System.Text.UTF8Encoding(false));
}
}
}
// Update the action that writes out the module manifests
foreach (Action Action in Actions)
{
if (Action.ActionType == ActionType.WriteMetadata)
{
string Arguments = Action.CommandArguments;
// Find the argument for the metadata file
const string InputArgument = "-Input=";
int InputIdx = Arguments.IndexOf(InputArgument);
if (InputIdx == -1)
{
throw new Exception("Missing -Input= argument to WriteMetadata command when patching action graph.");
}
int FileNameIdx = InputIdx + InputArgument.Length;
if (Arguments[FileNameIdx] == '\"')
{
FileNameIdx++;
}
int FileNameEndIdx = FileNameIdx;
while (FileNameEndIdx < Arguments.Length && (Arguments[FileNameEndIdx] != ' ' || Arguments[FileNameIdx - 1] == '\"') && Arguments[FileNameEndIdx] != '\"')
{
FileNameEndIdx++;
}
// Read the metadata file
FileReference TargetInfoFile = new FileReference(Arguments.Substring(FileNameIdx, FileNameEndIdx - FileNameIdx));
if (!FileReference.Exists(TargetInfoFile))
{
throw new Exception(String.Format("Unable to find metadata file to patch action graph ({0})", TargetInfoFile));
}
// Update the module names
WriteMetadataTargetInfo TargetInfo = BinaryFormatterUtils.Load <WriteMetadataTargetInfo>(TargetInfoFile);
foreach (KeyValuePair <FileReference, ModuleManifest> FileNameToVersionManifest in TargetInfo.FileToManifest)
{
KeyValuePair <string, string>[] ManifestEntries = FileNameToVersionManifest.Value.ModuleNameToFileName.ToArray();
foreach (KeyValuePair <string, string> Manifest in ManifestEntries)
{
FileReference OriginalFile = FileReference.Combine(FileNameToVersionManifest.Key.Directory, Manifest.Value);
FileReference HotReloadFile;
if (OriginalFileToHotReloadFile.TryGetValue(OriginalFile, out HotReloadFile))
{
FileNameToVersionManifest.Value.ModuleNameToFileName[Manifest.Key] = HotReloadFile.GetFileName();
}
}
}
// Write the hot-reload metadata file and update the argument list
FileReference HotReloadTargetInfoFile = FileReference.Combine(TargetInfoFile.Directory, "Metadata-HotReload.dat");
BinaryFormatterUtils.SaveIfDifferent(HotReloadTargetInfoFile, TargetInfo);
Action.PrerequisiteItems.RemoveAll(x => x.Location == TargetInfoFile);
Action.PrerequisiteItems.Add(FileItem.GetItemByFileReference(HotReloadTargetInfoFile));
Action.CommandArguments = Arguments.Substring(0, FileNameIdx) + HotReloadTargetInfoFile + Arguments.Substring(FileNameEndIdx);
}
}
}
public override FileItem LinkFiles(LinkEnvironment LinkEnvironment, bool bBuildImportLibraryOnly, ActionGraph ActionGraph)
{
FileItem OutputFile;
// Make the final javascript file
Action LinkAction = ActionGraph.Add(ActionType.Link);
LinkAction.CommandDescription = "Link";
// LinkAction.bPrintDebugInfo = true;
// ResponseFile lines.
List <string> ReponseLines = new List <string>();
LinkAction.bCanExecuteRemotely = false;
LinkAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
LinkAction.CommandPath = HTML5SDKInfo.Python();
LinkAction.CommandArguments = HTML5SDKInfo.EmscriptenCompiler();
// bool bIsBuildingLibrary = LinkEnvironment.bIsBuildingLibrary || bBuildImportLibraryOnly;
// ReponseLines.Add(
// bIsBuildingLibrary ?
// GetLibArguments(LinkEnvironment) :
// GetLinkArguments(LinkEnvironment)
// );
ReponseLines.Add(GetLinkArguments(LinkEnvironment));
// Add the input files to a response file, and pass the response file on the command-line.
foreach (FileItem InputFile in LinkEnvironment.InputFiles)
{
//System.Console.WriteLine("File {0} ", InputFile.AbsolutePath);
ReponseLines.Add(string.Format(" \"{0}\"", InputFile.AbsolutePath));
LinkAction.PrerequisiteItems.Add(InputFile);
}
if (!LinkEnvironment.bIsBuildingLibrary)
{
// Make sure ThirdParty libs are at the end.
List <string> ThirdParty = (from Lib in LinkEnvironment.AdditionalLibraries
where Lib.Contains("ThirdParty")
select Lib).ToList();
LinkEnvironment.AdditionalLibraries.RemoveAll(Element => Element.Contains("ThirdParty"));
LinkEnvironment.AdditionalLibraries.AddRange(ThirdParty);
foreach (string InputFile in LinkEnvironment.AdditionalLibraries)
{
FileItem Item = FileItem.GetItemByPath(InputFile);
if (Item.AbsolutePath.Contains(".lib"))
{
continue;
}
if (Item.ToString().EndsWith(".js"))
{
ReponseLines.Add(string.Format(" --js-library \"{0}\"", Item.AbsolutePath));
}
// WARNING: With --pre-js and --post-js, the order in which these directives are passed to
// the compiler is very critical, because that dictates the order in which they are appended.
//
// Set environment variable [ EMCC_DEBUG=1 ] to see the linker order used in packaging.
// See GetSharedArguments_Global() above to set this environment variable
else if (Item.ToString().EndsWith(".jspre"))
{
ReponseLines.Add(string.Format(" --pre-js \"{0}\"", Item.AbsolutePath));
}
else if (Item.ToString().EndsWith(".jspost"))
{
ReponseLines.Add(string.Format(" --post-js \"{0}\"", Item.AbsolutePath));
}
else
{
ReponseLines.Add(string.Format(" \"{0}\"", Item.AbsolutePath));
}
LinkAction.PrerequisiteItems.Add(Item);
}
}
// make the file we will create
OutputFile = FileItem.GetItemByFileReference(LinkEnvironment.OutputFilePath);
LinkAction.ProducedItems.Add(OutputFile);
ReponseLines.Add(string.Format(" -o \"{0}\"", OutputFile.AbsolutePath));
FileItem OutputBC = FileItem.GetItemByPath(LinkEnvironment.OutputFilePath.FullName.Replace(".js", ".bc").Replace(".html", ".bc"));
LinkAction.ProducedItems.Add(OutputBC);
ReponseLines.Add(string.Format(" --save-bc \"{0}\"", OutputBC.AbsolutePath));
LinkAction.StatusDescription = Path.GetFileName(OutputFile.AbsolutePath);
FileReference ResponseFileName = GetResponseFileName(LinkEnvironment, OutputFile);
FileItem ResponseFileItem = FileItem.CreateIntermediateTextFile(ResponseFileName, ReponseLines);
LinkAction.CommandArguments += string.Format(" @\"{0}\"", ResponseFileName);
LinkAction.PrerequisiteItems.Add(ResponseFileItem);
return(OutputFile);
}
public override CPPOutput CompileRCFiles(UEBuildTarget Target, CPPEnvironment Environment, List <FileItem> RCFiles)
{
var EnvVars = VCEnvironment.SetEnvironment(Environment.Config.Target.Platform, false);
CPPOutput Result = new CPPOutput();
var BuildPlatform = UEBuildPlatform.GetBuildPlatformForCPPTargetPlatform(Environment.Config.Target.Platform);
foreach (FileItem RCFile in RCFiles)
{
Action CompileAction = new Action(ActionType.Compile);
CompileAction.CommandDescription = "Resource";
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
CompileAction.CommandPath = EnvVars.ResourceCompilerPath;
CompileAction.StatusDescription = Path.GetFileName(RCFile.AbsolutePath);
// Suppress header spew
CompileAction.CommandArguments += " /nologo";
// If we're compiling for 64-bit Windows, also add the _WIN64 definition to the resource
// compiler so that we can switch on that in the .rc file using #ifdef.
CompileAction.CommandArguments += " /D_WIN64";
// Language
CompileAction.CommandArguments += " /l 0x409";
// Include paths.
foreach (string IncludePath in Environment.Config.CPPIncludeInfo.IncludePaths)
{
CompileAction.CommandArguments += string.Format(" /i \"{0}\"", IncludePath);
}
// System include paths.
foreach (var SystemIncludePath in Environment.Config.CPPIncludeInfo.SystemIncludePaths)
{
CompileAction.CommandArguments += string.Format(" /i \"{0}\"", SystemIncludePath);
}
// Preprocessor definitions.
foreach (string Definition in Environment.Config.Definitions)
{
CompileAction.CommandArguments += string.Format(" /d \"{0}\"", Definition);
}
// Add the RES file to the produced item list.
FileItem CompiledResourceFile = FileItem.GetItemByFileReference(
FileReference.Combine(
Environment.Config.OutputDirectory,
Path.GetFileName(RCFile.AbsolutePath) + ".res"
)
);
CompileAction.ProducedItems.Add(CompiledResourceFile);
CompileAction.CommandArguments += string.Format(" /fo \"{0}\"", CompiledResourceFile.AbsolutePath);
Result.ObjectFiles.Add(CompiledResourceFile);
// Add the RC file as a prerequisite of the action.
CompileAction.CommandArguments += string.Format(" \"{0}\"", RCFile.AbsolutePath);
// Add the C++ source file and its included files to the prerequisite item list.
AddPrerequisiteSourceFile(Target, BuildPlatform, Environment, RCFile, CompileAction.PrerequisiteItems);
}
return(Result);
}
/// <summary>
/// Checks to see if the assembly needs compilation
/// </summary>
/// <param name="SourceFiles">Set of source files</param>
/// <param name="AssemblyManifestFilePath">File containing information about this assembly, like which source files it was built with and engine version</param>
/// <param name="OutputAssemblyPath">Output path for the assembly</param>
/// <returns>True if the assembly needs to be built</returns>
private static bool RequiresCompilation(HashSet <FileReference> SourceFiles, FileReference AssemblyManifestFilePath, FileReference OutputAssemblyPath)
{
// Check to see if we already have a compiled assembly file on disk
FileItem OutputAssemblyInfo = FileItem.GetItemByFileReference(OutputAssemblyPath);
if (!OutputAssemblyInfo.Exists)
{
Log.TraceLog("Compiling {0}: Assembly does not exist", OutputAssemblyPath);
return(true);
}
// Check the time stamp of the UnrealBuildTool.exe file. If Unreal Build Tool was compiled more
// recently than the dynamically-compiled assembly, then we'll always recompile it. This is
// because Unreal Build Tool's code may have changed in such a way that invalidate these
// previously-compiled assembly files.
FileItem ExecutableItem = FileItem.GetItemByFileReference(UnrealBuildTool.GetUBTPath());
if (ExecutableItem.LastWriteTimeUtc > OutputAssemblyInfo.LastWriteTimeUtc)
{
Log.TraceLog("Compiling {0}: {1} is newer", OutputAssemblyPath, ExecutableItem.Name);
return(true);
}
// Make sure we have a manifest of source files used to compile the output assembly. If it doesn't exist
// for some reason (not an expected case) then we'll need to recompile.
FileItem AssemblySourceListFile = FileItem.GetItemByFileReference(AssemblyManifestFilePath);
if (!AssemblySourceListFile.Exists)
{
Log.TraceLog("Compiling {0}: Missing source file list ({1})", OutputAssemblyPath, AssemblyManifestFilePath);
return(true);
}
JsonObject Manifest = JsonObject.Read(AssemblyManifestFilePath);
// check if the engine version is different
string EngineVersionManifest = Manifest.GetStringField("EngineVersion");
string EngineVersionCurrent = FormatVersionNumber(ReadOnlyBuildVersion.Current);
if (EngineVersionManifest != EngineVersionCurrent)
{
Log.TraceLog("Compiling {0}: Engine Version changed from {1} to {2}", OutputAssemblyPath, EngineVersionManifest, EngineVersionCurrent);
return(true);
}
// Make sure the source files we're compiling are the same as the source files that were compiled
// for the assembly that we want to load
HashSet <FileItem> CurrentSourceFileItems = new HashSet <FileItem>();
foreach (string Line in Manifest.GetStringArrayField("SourceFiles"))
{
CurrentSourceFileItems.Add(FileItem.GetItemByPath(Line));
}
// Get the new source files
HashSet <FileItem> SourceFileItems = new HashSet <FileItem>();
foreach (FileReference SourceFile in SourceFiles)
{
SourceFileItems.Add(FileItem.GetItemByFileReference(SourceFile));
}
// Check if there are any differences between the sets
foreach (FileItem CurrentSourceFileItem in CurrentSourceFileItems)
{
if (!SourceFileItems.Contains(CurrentSourceFileItem))
{
Log.TraceLog("Compiling {0}: Removed source file ({1})", OutputAssemblyPath, CurrentSourceFileItem);
return(true);
}
}
foreach (FileItem SourceFileItem in SourceFileItems)
{
if (!CurrentSourceFileItems.Contains(SourceFileItem))
{
Log.TraceLog("Compiling {0}: Added source file ({1})", OutputAssemblyPath, SourceFileItem);
return(true);
}
}
// Check if any of the timestamps are newer
foreach (FileItem SourceFileItem in SourceFileItems)
{
if (SourceFileItem.LastWriteTimeUtc > OutputAssemblyInfo.LastWriteTimeUtc)
{
Log.TraceLog("Compiling {0}: {1} is newer", OutputAssemblyPath, SourceFileItem);
return(true);
}
}
return(false);
}
/// <summary>
/// Finds the header file that is referred to by a partial include filename.
/// </summary>
/// <param name="RelativeIncludePath">path relative to the project</param>
/// <param name="bSkipExternalHeader">true to skip processing of headers in external path</param>
/// <param name="SourceFilesDirectory">- The folder containing the source files we're generating a PCH for</param>
public static FileItem FindIncludedFile(string RelativeIncludePath, bool bSkipExternalHeader, List <string> IncludePathsToSearch, Dictionary <string, FileItem> IncludeFileSearchDictionary)
{
FileItem Result = null;
if (IncludePathsToSearch == null)
{
throw new BuildException("Was not expecting IncludePathsToSearch to be empty for file '{0}'!", RelativeIncludePath);
}
++TotalFindIncludedFileCalls;
// Only search for the include file if the result hasn't been cached.
string InvariantPath = RelativeIncludePath.ToLowerInvariant();
if (!IncludeFileSearchDictionary.TryGetValue(InvariantPath, out Result))
{
int SearchAttempts = 0;
if (Path.IsPathRooted(RelativeIncludePath))
{
FileReference Reference = new FileReference(RelativeIncludePath);
if (DirectoryLookupCache.FileExists(Reference))
{
Result = FileItem.GetItemByFileReference(Reference);
}
++SearchAttempts;
}
else
{
// Find the first include path that the included file exists in.
foreach (string IncludePath in IncludePathsToSearch)
{
++SearchAttempts;
string RelativeFilePath = "";
try
{
RelativeFilePath = Path.Combine(IncludePath, RelativeIncludePath);
}
catch (ArgumentException Exception)
{
throw new BuildException(Exception, "Failed to combine null or invalid include paths.");
}
FileReference FullFilePath = null;
try
{
FullFilePath = new FileReference(RelativeFilePath);
}
catch (Exception)
{
}
if (FullFilePath != null && DirectoryLookupCache.FileExists(FullFilePath))
{
Result = FileItem.GetItemByFileReference(FullFilePath);
break;
}
}
}
IncludePathSearchAttempts += SearchAttempts;
if (BuildConfiguration.bPrintPerformanceInfo)
{
// More than two search attempts indicates:
// - Include path was not relative to the directory that the including file was in
// - Include path was not relative to the project's base
if (SearchAttempts > 2)
{
Trace.TraceInformation(" Cache miss: " + RelativeIncludePath + " found after " + SearchAttempts.ToString() + " attempts: " + (Result != null ? Result.AbsolutePath : "NOT FOUND!"));
}
}
// Cache the result of the include path search.
IncludeFileSearchDictionary.Add(InvariantPath, Result);
}
// @todo ubtmake: The old UBT tried to skip 'external' (STABLE) headers here. But it didn't work. We might want to do this though! Skip system headers and source/thirdparty headers!
if (Result != null)
{
Log.TraceVerbose("Resolved included file \"{0}\" to: {1}", RelativeIncludePath, Result.AbsolutePath);
}
else
{
Log.TraceVerbose("Couldn't resolve included file \"{0}\"", RelativeIncludePath);
}
return(Result);
}
public override FileItem[] LinkAllFiles(LinkEnvironment LinkEnvironment, bool bBuildImportLibraryOnly)
{
List<FileItem> Outputs = new List<FileItem>();
var NDKRoot = Environment.GetEnvironmentVariable("NDKROOT").Replace("\\", "/");
int NDKApiLevelInt = GetNdkApiLevelInt();
string OptionalLinkArguments;
for (int ArchIndex = 0; ArchIndex < Arches.Count; ArchIndex++)
{
string Arch = Arches[ArchIndex];
// 32-bit ABI may need fixup for removed bsd_signal in NDK11 for android-21+
OptionalLinkArguments = "";
if (NDKApiLevelInt >= 21)
{
// this file was added in NDK11 so use existence to detect (RELEASE.TXT no longer present)
if (File.Exists(Path.Combine(NDKRoot, "source.properties")))
{
switch (Arch)
{
case "-armv7":
OptionalLinkArguments = string.Format(" \"{0}\"", Path.Combine(UnrealBuildTool.EngineDirectory.FullName, "Build/Android/Prebuilt/bsdsignal/lib/armeabi-v7a/libbsdsignal.a"));
break;
case "-x86":
OptionalLinkArguments = string.Format(" \"{0}\"", Path.Combine(UnrealBuildTool.EngineDirectory.FullName, "Build/Android/Prebuilt/bsdsignal/lib/x86/libbsdsignal.a"));
break;
}
}
}
for (int GPUArchIndex = 0; GPUArchIndex < GPUArchitectures.Count; GPUArchIndex++)
{
string GPUArchitecture = GPUArchitectures[GPUArchIndex];
int OutputPathIndex = ArchIndex * GPUArchitectures.Count + GPUArchIndex;
// Android will have an array of outputs
if (LinkEnvironment.Config.OutputFilePaths.Count < OutputPathIndex ||
!LinkEnvironment.Config.OutputFilePaths[OutputPathIndex].GetFileNameWithoutExtension().EndsWith(Arch + GPUArchitecture))
{
throw new BuildException("The OutputFilePaths array didn't match the Arches array in AndroidToolChain.LinkAllFiles");
}
// Create an action that invokes the linker.
Action LinkAction = new Action(ActionType.Link);
LinkAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
if (LinkEnvironment.Config.bIsBuildingLibrary)
{
switch (Arch)
{
case "-armv7": LinkAction.CommandPath = ArPathArm; break;
case "-arm64": LinkAction.CommandPath = ArPathArm64; break;
case "-x86": LinkAction.CommandPath = ArPathx86; ; break;
case "-x64": LinkAction.CommandPath = ArPathx64; ; break;
default: LinkAction.CommandPath = ArPathArm; ; break;
}
}
else
{
LinkAction.CommandPath = ClangPath;
}
string LinkerPath = LinkAction.WorkingDirectory;
LinkAction.WorkingDirectory = LinkEnvironment.Config.IntermediateDirectory.FullName;
// Get link arguments.
LinkAction.CommandArguments = LinkEnvironment.Config.bIsBuildingLibrary ? GetArArguments(LinkEnvironment) : GetLinkArguments(LinkEnvironment, Arch);
// Add the output file as a production of the link action.
FileItem OutputFile;
OutputFile = FileItem.GetItemByFileReference(LinkEnvironment.Config.OutputFilePaths[OutputPathIndex]);
Outputs.Add(OutputFile);
LinkAction.ProducedItems.Add(OutputFile);
LinkAction.StatusDescription = string.Format("{0}", Path.GetFileName(OutputFile.AbsolutePath));
// LinkAction.bPrintDebugInfo = true;
// Add the output file to the command-line.
if (LinkEnvironment.Config.bIsBuildingLibrary)
{
LinkAction.CommandArguments += string.Format(" \"{0}\"", OutputFile.AbsolutePath);
}
else
{
LinkAction.CommandArguments += string.Format(" -o \"{0}\"", OutputFile.AbsolutePath);
}
// Add the input files to a response file, and pass the response file on the command-line.
List<string> InputFileNames = new List<string>();
foreach (FileItem InputFile in LinkEnvironment.InputFiles)
{
// make sure it's for current Arch
if (Path.GetFileNameWithoutExtension(InputFile.AbsolutePath).EndsWith(Arch + GPUArchitecture))
{
string AbsolutePath = InputFile.AbsolutePath.Replace("\\", "/");
AbsolutePath = AbsolutePath.Replace(LinkEnvironment.Config.IntermediateDirectory.FullName.Replace("\\", "/"), "");
AbsolutePath = AbsolutePath.TrimStart(new char[] { '/' });
InputFileNames.Add(string.Format("\"{0}\"", AbsolutePath));
LinkAction.PrerequisiteItems.Add(InputFile);
}
}
FileReference ResponseFileName = GetResponseFileName(LinkEnvironment, OutputFile);
LinkAction.CommandArguments += string.Format(" @\"{0}\"", ResponseFile.Create(ResponseFileName, InputFileNames));
// libs don't link in other libs
if (!LinkEnvironment.Config.bIsBuildingLibrary)
{
// Add the library paths to the argument list.
foreach (string LibraryPath in LinkEnvironment.Config.LibraryPaths)
{
// LinkerPaths could be relative or absolute
string AbsoluteLibraryPath = ActionThread.ExpandEnvironmentVariables(LibraryPath);
if (IsDirectoryForArch(AbsoluteLibraryPath, Arch))
{
// environment variables aren't expanded when using the $( style
if (Path.IsPathRooted(AbsoluteLibraryPath) == false)
{
AbsoluteLibraryPath = Path.Combine(LinkerPath, AbsoluteLibraryPath);
}
LinkAction.CommandArguments += string.Format(" -L\"{0}\"", AbsoluteLibraryPath);
}
}
// add libraries in a library group
LinkAction.CommandArguments += string.Format(" -Wl,--start-group");
foreach (string AdditionalLibrary in LinkEnvironment.Config.AdditionalLibraries)
{
if (!ShouldSkipLib(AdditionalLibrary, Arch, GPUArchitecture))
{
if (String.IsNullOrEmpty(Path.GetDirectoryName(AdditionalLibrary)))
{
LinkAction.CommandArguments += string.Format(" \"-l{0}\"", AdditionalLibrary);
}
else
{
// full pathed libs are compiled by us, so we depend on linking them
LinkAction.CommandArguments += string.Format(" \"{0}\"", Path.GetFullPath(AdditionalLibrary));
LinkAction.PrerequisiteItems.Add(FileItem.GetItemByPath(AdditionalLibrary));
}
}
}
LinkAction.CommandArguments += OptionalLinkArguments;
LinkAction.CommandArguments += string.Format(" -Wl,--end-group");
}
// Add the additional arguments specified by the environment.
LinkAction.CommandArguments += LinkEnvironment.Config.AdditionalArguments;
LinkAction.CommandArguments = LinkAction.CommandArguments.Replace("\\", "/");
// Only execute linking on the local PC.
LinkAction.bCanExecuteRemotely = false;
}
}
return Outputs.ToArray();
}
public override CPPOutput CompileCPPFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, string ModuleName, IActionGraphBuilder Graph)
{
// Use a subdirectory for PVS output, to avoid clobbering regular build artifacts
OutputDir = DirectoryReference.Combine(OutputDir, "PVS");
// Preprocess the source files with the regular toolchain
CppCompileEnvironment PreprocessCompileEnvironment = new CppCompileEnvironment(CompileEnvironment);
PreprocessCompileEnvironment.bPreprocessOnly = true;
PreprocessCompileEnvironment.bEnableUndefinedIdentifierWarnings = false; // Not sure why THIRD_PARTY_INCLUDES_START doesn't pick this up; the _Pragma appears in the preprocessed output. Perhaps in preprocess-only mode the compiler doesn't respect these?
PreprocessCompileEnvironment.Definitions.Add("PVS_STUDIO");
List <Action> PreprocessActions = new List <Action>();
CPPOutput Result = InnerToolChain.CompileCPPFiles(PreprocessCompileEnvironment, InputFiles, OutputDir, ModuleName, new ActionGraphCapture(Graph, PreprocessActions));
// Run the source files through PVS-Studio
foreach (Action PreprocessAction in PreprocessActions)
{
if (PreprocessAction.ActionType != ActionType.Compile)
{
continue;
}
FileItem SourceFileItem = PreprocessAction.PrerequisiteItems.FirstOrDefault(x => x.HasExtension(".c") || x.HasExtension(".cc") || x.HasExtension(".cpp"));
if (SourceFileItem == null)
{
Log.TraceWarning("Unable to find source file from command: {0} {1}", PreprocessAction.CommandArguments);
continue;
}
FileItem PreprocessedFileItem = PreprocessAction.ProducedItems.FirstOrDefault(x => x.HasExtension(".i"));
if (PreprocessedFileItem == null)
{
Log.TraceWarning("Unable to find preprocessed output file from command: {0} {1}", PreprocessAction.CommandArguments);
continue;
}
// Disable a few warnings that seem to come from the preprocessor not respecting _Pragma
PreprocessAction.CommandArguments += " /wd4005"; // macro redefinition
PreprocessAction.CommandArguments += " /wd4828"; // file contains a character starting at offset xxxx that is illegal in the current source character set
// Write the PVS studio config file
StringBuilder ConfigFileContents = new StringBuilder();
foreach (DirectoryReference IncludePath in Target.WindowsPlatform.Environment.IncludePaths)
{
ConfigFileContents.AppendFormat("exclude-path={0}\n", IncludePath.FullName);
}
if (ApplicationSettings != null && ApplicationSettings.PathMasks != null)
{
foreach (string PathMask in ApplicationSettings.PathMasks)
{
if (PathMask.Contains(":") || PathMask.Contains("\\") || PathMask.Contains("/"))
{
if (Path.IsPathRooted(PathMask) && !PathMask.Contains(":"))
{
ConfigFileContents.AppendFormat("exclude-path=*{0}*\n", PathMask);
}
else
{
ConfigFileContents.AppendFormat("exclude-path={0}\n", PathMask);
}
}
}
}
if (Platform == UnrealTargetPlatform.Win64)
{
ConfigFileContents.Append("platform=x64\n");
}
else if (Platform == UnrealTargetPlatform.Win32)
{
ConfigFileContents.Append("platform=Win32\n");
}
else
{
throw new BuildException("PVS-Studio does not support this platform");
}
ConfigFileContents.Append("preprocessor=visualcpp\n");
ConfigFileContents.Append("language=C++\n");
ConfigFileContents.Append("skip-cl-exe=yes\n");
ConfigFileContents.AppendFormat("i-file={0}\n", PreprocessedFileItem.Location.FullName);
string BaseFileName = PreprocessedFileItem.Location.GetFileNameWithoutExtension();
FileReference ConfigFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".cfg");
FileItem ConfigFileItem = Graph.CreateIntermediateTextFile(ConfigFileLocation, ConfigFileContents.ToString());
// Run the analzyer on the preprocessed source file
FileReference OutputFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".pvslog");
FileItem OutputFileItem = FileItem.GetItemByFileReference(OutputFileLocation);
Action AnalyzeAction = Graph.CreateAction(ActionType.Compile);
AnalyzeAction.CommandDescription = "Analyzing";
AnalyzeAction.StatusDescription = BaseFileName;
AnalyzeAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory;
AnalyzeAction.CommandPath = AnalyzerFile;
AnalyzeAction.CommandArguments = String.Format("--cl-params \"{0}\" --source-file \"{1}\" --output-file \"{2}\" --cfg \"{3}\" --analysis-mode {4}", PreprocessAction.CommandArguments, SourceFileItem.AbsolutePath, OutputFileLocation, ConfigFileItem.AbsolutePath, (uint)Settings.ModeFlags);
if (LicenseFile != null)
{
AnalyzeAction.CommandArguments += String.Format(" --lic-file \"{0}\"", LicenseFile);
AnalyzeAction.PrerequisiteItems.Add(FileItem.GetItemByFileReference(LicenseFile));
}
AnalyzeAction.PrerequisiteItems.Add(ConfigFileItem);
AnalyzeAction.PrerequisiteItems.Add(PreprocessedFileItem);
AnalyzeAction.PrerequisiteItems.AddRange(InputFiles); // Add the InputFiles as PrerequisiteItems so that in SingleFileCompile mode the PVSAnalyze step is not filtered out
AnalyzeAction.ProducedItems.Add(OutputFileItem);
AnalyzeAction.DeleteItems.Add(OutputFileItem); // PVS Studio will append by default, so need to delete produced items
Result.ObjectFiles.AddRange(AnalyzeAction.ProducedItems);
}
return(Result);
}
public override CPPOutput CompileCPPFiles(UEBuildTarget Target, CPPEnvironment CompileEnvironment, List<FileItem> SourceFiles, string ModuleName)
{
if (Arches.Count == 0)
{
throw new BuildException("At least one architecture (armv7, x86, etc) needs to be selected in the project settings to build");
}
if (!bHasPrintedApiLevel)
{
Console.WriteLine("Compiling Native code with NDK API '{0}'", GetNdkApiLevel());
bHasPrintedApiLevel = true;
}
string BaseArguments = "";
if (CompileEnvironment.Config.PrecompiledHeaderAction != PrecompiledHeaderAction.Create)
{
BaseArguments += " -Werror";
}
// Directly added NDK files for NDK extensions
ConditionallyAddNDKSourceFiles(SourceFiles, ModuleName);
// Deal with dynamic modules removed by architecture
GenerateEmptyLinkFunctionsForRemovedModules(SourceFiles, ModuleName, CompileEnvironment.Config.OutputDirectory);
// Add preprocessor definitions to the argument list.
foreach (string Definition in CompileEnvironment.Config.Definitions)
{
BaseArguments += string.Format(" -D \"{0}\"", Definition);
}
var BuildPlatform = UEBuildPlatform.GetBuildPlatformForCPPTargetPlatform(CompileEnvironment.Config.Target.Platform);
var NDKRoot = Environment.GetEnvironmentVariable("NDKROOT").Replace("\\", "/");
string BasePCHName = "";
var PCHExtension = UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.Android).GetBinaryExtension(UEBuildBinaryType.PrecompiledHeader);
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Include)
{
BasePCHName = RemoveArchName(CompileEnvironment.PrecompiledHeaderFile.AbsolutePath).Replace(PCHExtension, "");
}
// Create a compile action for each source file.
CPPOutput Result = new CPPOutput();
foreach (string Arch in Arches)
{
if (ShouldSkipModule(ModuleName, Arch))
{
continue;
}
foreach (string GPUArchitecture in GPUArchitectures)
{
// which toolchain to use
string Arguments = GetCLArguments_Global(CompileEnvironment, Arch) + BaseArguments;
switch (Arch)
{
case "-armv7": Arguments += " -DPLATFORM_64BITS=0 -DPLATFORM_ANDROID_ARM=1"; break;
case "-arm64": Arguments += " -DPLATFORM_64BITS=1 -DPLATFORM_ANDROID_ARM64=1"; break;
case "-x86": Arguments += " -DPLATFORM_64BITS=0 -DPLATFORM_ANDROID_X86=1"; break;
case "-x64": Arguments += " -DPLATFORM_64BITS=1 -DPLATFORM_ANDROID_X64=1"; break;
default: Arguments += " -DPLATFORM_64BITS=0 -DPLATFORM_ANDROID_ARM=1"; break;
}
if (GPUArchitecture == "-esdeferred")
{
Arguments += " -DPLATFORM_ANDROIDESDEFERRED=1";
}
// which PCH file to include
string PCHArguments = "";
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Include)
{
// Add the precompiled header file's path to the include path so Clang can find it.
// This needs to be before the other include paths to ensure Clang uses it instead of the source header file.
PCHArguments += string.Format(" -include \"{0}\"", InlineArchName(BasePCHName, Arch, GPUArchitecture));
}
// Add include paths to the argument list (filtered by architecture)
foreach (string IncludePath in CompileEnvironment.Config.CPPIncludeInfo.SystemIncludePaths)
{
if (IsDirectoryForArch(IncludePath, Arch))
{
Arguments += string.Format(" -I\"{0}\"", IncludePath);
}
}
foreach (string IncludePath in CompileEnvironment.Config.CPPIncludeInfo.IncludePaths)
{
if (IsDirectoryForArch(IncludePath, Arch))
{
Arguments += string.Format(" -I\"{0}\"", IncludePath);
}
}
foreach (FileItem SourceFile in SourceFiles)
{
Action CompileAction = new Action(ActionType.Compile);
string FileArguments = "";
bool bIsPlainCFile = Path.GetExtension(SourceFile.AbsolutePath).ToUpperInvariant() == ".C";
bool bDisableShadowWarning = false;
// should we disable optimizations on this file?
// @todo android - We wouldn't need this if we could disable optimizations per function (via pragma)
bool bDisableOptimizations = false;// SourceFile.AbsolutePath.ToUpperInvariant().IndexOf("\\SLATE\\") != -1;
if (bDisableOptimizations && CompileEnvironment.Config.Target.Configuration != CPPTargetConfiguration.Debug)
{
Log.TraceWarning("Disabling optimizations on {0}", SourceFile.AbsolutePath);
}
bDisableOptimizations = bDisableOptimizations || CompileEnvironment.Config.Target.Configuration == CPPTargetConfiguration.Debug;
// Add C or C++ specific compiler arguments.
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Create)
{
FileArguments += GetCompileArguments_PCH(bDisableOptimizations);
}
else if (bIsPlainCFile)
{
FileArguments += GetCompileArguments_C(bDisableOptimizations);
// remove shadow variable warnings for NDK files
if (SourceFile.AbsolutePath.Replace("\\", "/").StartsWith(NDKRoot))
{
bDisableShadowWarning = true;
}
}
else
{
FileArguments += GetCompileArguments_CPP(bDisableOptimizations);
// only use PCH for .cpp files
FileArguments += PCHArguments;
}
// Add the C++ source file and its included files to the prerequisite item list.
AddPrerequisiteSourceFile(Target, BuildPlatform, CompileEnvironment, SourceFile, CompileAction.PrerequisiteItems);
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Create)
{
// Add the precompiled header file to the produced item list.
FileItem PrecompiledHeaderFile = FileItem.GetItemByFileReference(
FileReference.Combine(
CompileEnvironment.Config.OutputDirectory,
Path.GetFileName(InlineArchName(SourceFile.AbsolutePath, Arch, GPUArchitecture) + PCHExtension)
)
);
CompileAction.ProducedItems.Add(PrecompiledHeaderFile);
Result.PrecompiledHeaderFile = PrecompiledHeaderFile;
// Add the parameters needed to compile the precompiled header file to the command-line.
FileArguments += string.Format(" -o \"{0}\"", PrecompiledHeaderFile.AbsolutePath, false);
}
else
{
if (CompileEnvironment.Config.PrecompiledHeaderAction == PrecompiledHeaderAction.Include)
{
CompileAction.bIsUsingPCH = true;
FileItem ArchPrecompiledHeaderFile = FileItem.GetItemByPath(InlineArchName(BasePCHName, Arch, GPUArchitecture) + PCHExtension);
CompileAction.PrerequisiteItems.Add(ArchPrecompiledHeaderFile);
}
var ObjectFileExtension = UEBuildPlatform.GetBuildPlatform(UnrealTargetPlatform.Android).GetBinaryExtension(UEBuildBinaryType.Object);
// Add the object file to the produced item list.
FileItem ObjectFile = FileItem.GetItemByFileReference(
FileReference.Combine(
CompileEnvironment.Config.OutputDirectory,
InlineArchName(Path.GetFileName(SourceFile.AbsolutePath) + ObjectFileExtension, Arch, GPUArchitecture)
)
);
CompileAction.ProducedItems.Add(ObjectFile);
Result.ObjectFiles.Add(ObjectFile);
FileArguments += string.Format(" -o \"{0}\"", ObjectFile.AbsolutePath, false);
}
// Add the source file path to the command-line.
FileArguments += string.Format(" \"{0}\"", SourceFile.AbsolutePath);
// Build a full argument list
string AllArguments = Arguments + FileArguments + CompileEnvironment.Config.AdditionalArguments;
AllArguments = ActionThread.ExpandEnvironmentVariables(AllArguments);
AllArguments = AllArguments.Replace("\\", "/");
// Remove shadow warning for this file if requested
if (bDisableShadowWarning)
{
int WarningIndex = AllArguments.IndexOf(" -Wshadow");
if (WarningIndex > 0)
{
AllArguments = AllArguments.Remove(WarningIndex, 9);
}
}
// Create the response file
FileReference ResponseFileName = CompileAction.ProducedItems[0].Reference + "_" + AllArguments.GetHashCode().ToString("X") + ".response";
string ResponseArgument = string.Format("@\"{0}\"", ResponseFile.Create(ResponseFileName, new List<string> { AllArguments }).FullName);
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
CompileAction.CommandPath = ClangPath;
CompileAction.CommandArguments = ResponseArgument;
CompileAction.StatusDescription = string.Format("{0} [{1}-{2}]", Path.GetFileName(SourceFile.AbsolutePath), Arch.Replace("-", ""), GPUArchitecture.Replace("-", ""));
// VC++ always outputs the source file name being compiled, so we don't need to emit this ourselves
CompileAction.bShouldOutputStatusDescription = true;
// Don't farm out creation of pre-compiled headers as it is the critical path task.
CompileAction.bCanExecuteRemotely =
CompileEnvironment.Config.PrecompiledHeaderAction != PrecompiledHeaderAction.Create ||
BuildConfiguration.bAllowRemotelyCompiledPCHs;
}
}
}
return Result;
}
public override CPPOutput CompileCPPFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, string ModuleName, ActionGraph ActionGraph)
{
VCEnvironment EnvVars = VCEnvironment.SetEnvironment(CppPlatform, Compiler);
// Get the MSVC arguments required to compile all files in this batch
List <string> SharedArguments = new List <string>();
SharedArguments.Add("/nologo");
SharedArguments.Add("/P"); // Preprocess
SharedArguments.Add("/C"); // Preserve comments when preprocessing
SharedArguments.Add("/D PVS_STUDIO");
SharedArguments.Add("/wd4005");
foreach (DirectoryReference IncludePath in CompileEnvironment.IncludePaths.UserIncludePaths)
{
SharedArguments.Add(String.Format("/I \"{0}\"", IncludePath));
}
foreach (DirectoryReference IncludePath in CompileEnvironment.IncludePaths.SystemIncludePaths)
{
SharedArguments.Add(String.Format("/I \"{0}\"", IncludePath));
}
foreach (string Definition in CompileEnvironment.Definitions)
{
SharedArguments.Add(String.Format("/D \"{0}\"", Definition));
}
// Get the path to PVS studio
FileReference AnalyzerFile = new FileReference(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFilesX86), "PVS-Studio", "x64", "PVS-Studio.exe"));
if (!FileReference.Exists(AnalyzerFile))
{
throw new BuildException("Unable to find PVS-Studio at {0}", AnalyzerFile);
}
CPPOutput Result = new CPPOutput();
foreach (FileItem SourceFile in InputFiles)
{
// Get the file names for everything we need
string BaseFileName = SourceFile.Location.GetFileName();
// Write the response file
FileReference PreprocessedFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".i");
List <string> Arguments = new List <string>(SharedArguments);
Arguments.Add(String.Format("/Fi\"{0}\"", PreprocessedFileLocation)); // Preprocess to a file
Arguments.Add(String.Format("\"{0}\"", SourceFile.AbsolutePath));
FileReference ResponseFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".i.response");
FileItem ResponseFileItem = FileItem.CreateIntermediateTextFile(ResponseFileLocation, String.Join("\n", Arguments));
// Preprocess the source file
FileItem PreprocessedFileItem = FileItem.GetItemByFileReference(PreprocessedFileLocation);
Action PreprocessAction = ActionGraph.Add(ActionType.Compile);
PreprocessAction.CommandPath = EnvVars.CompilerPath.FullName;
PreprocessAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
PreprocessAction.CommandArguments = " @\"" + ResponseFileItem.AbsolutePath + "\"";
PreprocessAction.PrerequisiteItems.Add(SourceFile);
PreprocessAction.PrerequisiteItems.Add(ResponseFileItem);
PreprocessAction.ProducedItems.Add(PreprocessedFileItem);
PreprocessAction.bShouldOutputStatusDescription = false;
// Write the PVS studio config file
StringBuilder ConfigFileContents = new StringBuilder();
ConfigFileContents.AppendFormat("exclude-path={0}\n", EnvVars.VCInstallDir.FullName);
if (CppPlatform == CppPlatform.Win64)
{
ConfigFileContents.Append("platform=x64\n");
}
else if (CppPlatform == CppPlatform.Win32)
{
ConfigFileContents.Append("platform=Win32\n");
}
else
{
throw new BuildException("PVS studio does not support this platform");
}
ConfigFileContents.Append("preprocessor=visualcpp\n");
ConfigFileContents.Append("language=C++\n");
ConfigFileContents.Append("skip-cl-exe=yes\n");
ConfigFileContents.AppendFormat("i-file={0}\n", PreprocessedFileItem.Location.FullName);
FileReference ConfigFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".cfg");
FileItem ConfigFileItem = FileItem.CreateIntermediateTextFile(ConfigFileLocation, ConfigFileContents.ToString());
// Run the analzyer on the preprocessed source file
FileReference OutputFileLocation = FileReference.Combine(OutputDir, BaseFileName + ".pvslog");
FileItem OutputFileItem = FileItem.GetItemByFileReference(OutputFileLocation);
Action AnalyzeAction = ActionGraph.Add(ActionType.Compile);
AnalyzeAction.CommandDescription = "Analyzing";
AnalyzeAction.StatusDescription = BaseFileName;
AnalyzeAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory.FullName;
AnalyzeAction.CommandPath = AnalyzerFile.FullName;
AnalyzeAction.CommandArguments = String.Format("--cl-params \"{0}\" --source-file \"{1}\" --output-file \"{2}\" --cfg \"{3}\" --analysis-mode 4", PreprocessAction.CommandArguments, SourceFile.AbsolutePath, OutputFileLocation, ConfigFileItem.AbsolutePath);
AnalyzeAction.PrerequisiteItems.Add(ConfigFileItem);
AnalyzeAction.PrerequisiteItems.Add(PreprocessedFileItem);
AnalyzeAction.ProducedItems.Add(OutputFileItem);
AnalyzeAction.bShouldDeleteProducedItems = true; // PVS Studio will append by default, so need to delete produced items
Result.ObjectFiles.AddRange(AnalyzeAction.ProducedItems);
}
return(Result);
}
public override CPPOutput GenerateISPCHeaders(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, IActionGraphBuilder Graph)
{
CPPOutput Result = new CPPOutput();
if (!CompileEnvironment.bCompileISPC)
{
return(Result);
}
List <string> CompileTargets = GetISPCCompileTargets(CompileEnvironment.Platform, null);
foreach (FileItem ISPCFile in InputFiles)
{
Action CompileAction = Graph.CreateAction(ActionType.Compile);
CompileAction.CommandDescription = "Compile";
CompileAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory;
CompileAction.CommandPath = new FileReference(GetISPCHostCompilerPath(BuildHostPlatform.Current.Platform));
CompileAction.StatusDescription = Path.GetFileName(ISPCFile.AbsolutePath);
// Disable remote execution to workaround mismatched case on XGE
CompileAction.bCanExecuteRemotely = false;
List <string> Arguments = new List <string>();
// Add the ISPC obj file as a prerequisite of the action.
CompileAction.CommandArguments = String.Format("\"{0}\" ", ISPCFile.AbsolutePath);
// Add the ISPC h file to the produced item list.
FileItem ISPCIncludeHeaderFile = FileItem.GetItemByFileReference(
FileReference.Combine(
OutputDir,
Path.GetFileName(ISPCFile.AbsolutePath) + ".generated.dummy.h"
)
);
// Add the ISPC file to be compiled.
Arguments.Add(String.Format("-h \"{0}\"", ISPCIncludeHeaderFile));
// Build target string. No comma on last
string TargetString = "";
foreach (string Target in CompileTargets)
{
if (Target == CompileTargets[CompileTargets.Count - 1]) // .Last()
{
TargetString += Target;
}
else
{
TargetString += Target + ",";
}
}
// Build target triplet
Arguments.Add(String.Format("--target-os={0}", GetISPCOSTarget(CompileEnvironment.Platform)));
Arguments.Add(String.Format("--arch={0}", GetISPCArchTarget(CompileEnvironment.Platform, null)));
Arguments.Add(String.Format("--target={0}", TargetString));
// PIC is needed for modular builds except on Windows
if ((CompileEnvironment.bIsBuildingDLL ||
CompileEnvironment.bIsBuildingLibrary) &&
!UEBuildPlatform.IsPlatformInGroup(CompileEnvironment.Platform, UnrealPlatformGroup.Windows))
{
Arguments.Add("--pic");
}
// Include paths. Don't use AddIncludePath() here, since it uses the full path and exceeds the max command line length.
// Because ISPC response files don't support white space in arguments, paths with white space need to be passed to the command line directly.
foreach (DirectoryReference IncludePath in CompileEnvironment.UserIncludePaths)
{
Arguments.Add(String.Format("-I\"{0}\"", IncludePath));
}
// System include paths.
foreach (DirectoryReference SystemIncludePath in CompileEnvironment.SystemIncludePaths)
{
Arguments.Add(String.Format("-I\"{0}\"", SystemIncludePath));
}
// Generate the included header dependency list
if (CompileEnvironment.bGenerateDependenciesFile)
{
FileItem DependencyListFile = FileItem.GetItemByFileReference(FileReference.Combine(OutputDir, Path.GetFileName(ISPCFile.AbsolutePath) + ".txt"));
Arguments.Add(String.Format("-MMM \"{0}\"", DependencyListFile.AbsolutePath.Replace('\\', '/')));
CompileAction.DependencyListFile = DependencyListFile;
CompileAction.ProducedItems.Add(DependencyListFile);
}
CompileAction.ProducedItems.Add(ISPCIncludeHeaderFile);
FileReference ResponseFileName = new FileReference(ISPCIncludeHeaderFile.AbsolutePath + ".response");
FileItem ResponseFileItem = Graph.CreateIntermediateTextFile(ResponseFileName, Arguments.Select(x => Utils.ExpandVariables(x)));
CompileAction.CommandArguments += String.Format("@\"{0}\"", ResponseFileName);
CompileAction.PrerequisiteItems.Add(ResponseFileItem);
// Add the source file and its included files to the prerequisite item list.
CompileAction.PrerequisiteItems.Add(ISPCFile);
FileItem ISPCFinalHeaderFile = FileItem.GetItemByFileReference(
FileReference.Combine(
OutputDir,
Path.GetFileName(ISPCFile.AbsolutePath) + ".generated.h"
)
);
// Fix interrupted build issue by copying header after generation completes
FileReference SourceFile = ISPCIncludeHeaderFile.Location;
FileReference TargetFile = ISPCFinalHeaderFile.Location;
FileItem SourceFileItem = FileItem.GetItemByFileReference(SourceFile);
FileItem TargetFileItem = FileItem.GetItemByFileReference(TargetFile);
Action CopyAction = Graph.CreateAction(ActionType.BuildProject);
CopyAction.CommandDescription = "Copy";
CopyAction.CommandPath = BuildHostPlatform.Current.Shell;
if (BuildHostPlatform.Current.ShellType == ShellType.Cmd)
{
CopyAction.CommandArguments = String.Format("/C \"copy /Y \"{0}\" \"{1}\" 1>nul\"", SourceFile, TargetFile);
}
else
{
CopyAction.CommandArguments = String.Format("-c 'cp -f \"{0}\" \"{1}\"'", SourceFile.FullName, TargetFile.FullName);
}
CopyAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory;
CopyAction.PrerequisiteItems.Add(SourceFileItem);
CopyAction.ProducedItems.Add(TargetFileItem);
CopyAction.StatusDescription = TargetFileItem.Location.GetFileName();
CopyAction.bCanExecuteRemotely = false;
CopyAction.bShouldOutputStatusDescription = false;
Result.GeneratedHeaderFiles.Add(TargetFileItem);
Log.TraceVerbose(" ISPC Generating Header " + CompileAction.StatusDescription + ": \"" + CompileAction.CommandPath + "\"" + CompileAction.CommandArguments);
}
return(Result);
}