public override FileItem LinkFiles(LinkEnvironment LinkEnvironment, bool bBuildImportLibraryOnly, IActionGraphBuilder Graph)
{
FileItem OutputFile = FileItem.GetItemByFileReference(LinkEnvironment.OutputFilePath);
Action LinkAction = Graph.CreateAction(ActionType.Link);
LinkAction.CommandDescription = "FakeCompile";
LinkAction.CommandPath = BuildHostPlatform.Current.Shell;
if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Win64)
{
LinkAction.CommandArguments = String.Format("/C echo Linked > {0}", LinkEnvironment.OutputFilePath.FullName);
}
else
{
LinkAction.CommandArguments = String.Format("echo Linked > {0}", Utils.EscapeShellArgument(LinkEnvironment.OutputFilePath.FullName));
}
LinkAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory;
foreach (FileItem InputFile in LinkEnvironment.InputFiles)
{
LinkAction.PrerequisiteItems.Add(InputFile);
}
LinkAction.ProducedItems.Add(OutputFile);
LinkAction.DeleteItems.Add(OutputFile);
LinkAction.StatusDescription = OutputFile.Location.GetFileName();
LinkAction.bCanExecuteRemotely = false;
return(OutputFile);
}
/// <summary>
/// Creates an action which calls UBT recursively
/// </summary>
/// <param name="Graph">The action graph</param>
/// <param name="Type">Type of the action</param>
/// <param name="Arguments">Arguments for the action</param>
/// <returns>New action instance</returns>
public static Action CreateRecursiveAction <T>(this IActionGraphBuilder Graph, ActionType Type, string Arguments) where T : ToolMode
{
ToolModeAttribute Attribute = typeof(T).GetCustomAttribute <ToolModeAttribute>();
if (Attribute == null)
{
throw new BuildException("Missing ToolModeAttribute on {0}", typeof(T).Name);
}
Action NewAction = Graph.CreateAction(Type);
NewAction.CommandPath = UnrealBuildTool.GetUBTPath();
NewAction.CommandArguments = String.Format("-Mode={0} {1}", Attribute.Name, Arguments);
return(NewAction);
}
/// <summary>
/// Creates an action which copies a file from one location to another
/// </summary>
/// <param name="Graph">The action graph</param>
/// <param name="SourceFile">The source file location</param>
/// <param name="TargetFile">The target file location</param>
/// <returns>File item for the output file</returns>
public static Action CreateCopyAction(this IActionGraphBuilder Graph, FileItem SourceFile, FileItem 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.AbsolutePath, TargetFile.AbsolutePath);
}
else
{
CopyAction.CommandArguments = String.Format("-c 'cp -f \"{0}\" \"{1}\"'", SourceFile.AbsolutePath, TargetFile.AbsolutePath);
}
CopyAction.WorkingDirectory = UnrealBuildTool.EngineSourceDirectory;
CopyAction.PrerequisiteItems.Add(SourceFile);
CopyAction.ProducedItems.Add(TargetFile);
CopyAction.DeleteItems.Add(TargetFile);
CopyAction.StatusDescription = TargetFile.Location.GetFileName();
CopyAction.bCanExecuteRemotely = false;
return(CopyAction);
}
public override CPPOutput CompileCPPFiles(CppCompileEnvironment CompileEnvironment, List <FileItem> InputFiles, DirectoryReference OutputDir, string ModuleName, IActionGraphBuilder Graph)
{
// 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 = Graph.CreateAction(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);
}
}
return(Result);
}
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 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);
}
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);
}
/// <inheritdoc/>
public virtual Action CreateAction(ActionType Type)
{
return(Inner.CreateAction(Type));
}
