UnrealEngineUWP/Engine/Source/Developer/CrashDebugHelper/Private/CrashDebugHelper.cpp

// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.

#include "CrashDebugHelperPrivatePCH.h"
#include "CrashDebugPDBCache.h"

#include "EngineVersion.h"
#include "ISourceControlModule.h"
#include "ISourceControlLabel.h"
#include "ISourceControlRevision.h"

#ifndef MINIDUMPDIAGNOSTICS
	#define MINIDUMPDIAGNOSTICS	0
#endif

/*-----------------------------------------------------------------------------
	FCrashDebugHelperConfig
-----------------------------------------------------------------------------*/

/**
*  Holds FullCrashDump properties from the config.
*
*	PDBCache_0_Branch=UE4-Branch
*	PDBCache_0_ExecutablePathPattern=ue4.net\Builds\UE4-Branch\%ENGINE_VERSION%
*	PDBCache_0_SymbolPathPattern=ue4.net\Builds\UE4-Branch\%ENGINE_VERSION%
*	
*	If PDBCache_0_SymbolPathPattern is missing, the value from PDBCache_0_ExecutablePathPattern will be used
*/
struct FPDBCacheConfigEntry
{
	/** Initialization constructor. */
	FPDBCacheConfigEntry( const FString& InBranch, const FString& InExecutablePathPattern, const FString& InSymbolPathPattern )
		: Branch( InBranch )
		, ExecutablePathPattern( InExecutablePathPattern )
		, SymbolPathPattern( InSymbolPathPattern )
	{}


	/** Branch name. */
	const FString Branch;

	/** Location of the executables */
	const FString ExecutablePathPattern;

	/** Location of the symbols, usually the same as the executables. */
	const FString SymbolPathPattern;
};

/** Helper struct for reading PDB cache configuration. */
struct FCrashDebugHelperConfig
{
	static FCrashDebugHelperConfig& Get()
	{
		static FCrashDebugHelperConfig Instance;
		return Instance;
	}

	bool IsValid() const
	{
		// We need a least one entry to proceed.
		return PDBCacheConfigEntries.Num() > 0;
	}

	/** Reads configuration. */
	void ReadFullCrashDumpConfigurations();

	/** Gets the config for branch. */
	FPDBCacheConfigEntry GetCacheConfigEntryForBranch( const FString& Branch ) const
	{
		const FString BranchFixed = Branch.Replace( TEXT( "/" ), TEXT( "+" ) );
		for (const auto& It : PDBCacheConfigEntries)
		{
			if (BranchFixed.Contains( It.Branch ))
			{
				return It;
			}
		}

		// Invalid entry.
		return FPDBCacheConfigEntry( Branch, FString(), FString() );
	}

protected:
	/** Returns empty string if couldn't read. */
	FString GetKey( const FString& KeyName );

	/** Configuration for PDB Cache. */
	TArray<FPDBCacheConfigEntry> PDBCacheConfigEntries;
};

void FCrashDebugHelperConfig::ReadFullCrashDumpConfigurations()
{
	for (int32 NumEntries = 0;; ++NumEntries)
	{
		const FString Branch = GetKey( FString::Printf( TEXT( "PDBCache_%i_Branch" ), NumEntries ) );
		if (Branch.IsEmpty())
		{
			break;
		}

		const FString ExecutablePathPattern = GetKey( FString::Printf( TEXT( "PDBCache_%i_ExecutablePathPattern" ), NumEntries ) );
		if (ExecutablePathPattern.IsEmpty())
		{
			break;
		}

		FString SymbolPathPattern = GetKey( FString::Printf( TEXT( "PDBCache_%i_SymbolPathPattern" ), NumEntries ) );
		if (SymbolPathPattern.IsEmpty())
		{
			SymbolPathPattern = ExecutablePathPattern;
		}
		
		PDBCacheConfigEntries.Add( FPDBCacheConfigEntry( Branch, ExecutablePathPattern, SymbolPathPattern ) );

		UE_LOG( LogCrashDebugHelper, Log, TEXT( "PDBCacheConfigEntry: Branch:%s ExecutablePathPattern:%s SymbolPathPattern:%s" ), *Branch, *ExecutablePathPattern, *SymbolPathPattern );
	}
}

FString FCrashDebugHelperConfig::GetKey( const FString& KeyName )
{
	const FString SectionName = TEXT( "Engine.CrashDebugHelper" );

	FString Result;
	if (!GConfig->GetString( *SectionName, *KeyName, Result, GEngineIni ))
	{
		return TEXT( "" );
	}
	return Result;
}

/*-----------------------------------------------------------------------------
	ICrashDebugHelper
-----------------------------------------------------------------------------*/

void ICrashDebugHelper::SetDepotIndex( FString& PathToChange )
{
	FString CmdDepotIndex;
	FParse::Value( FCommandLine::Get(), TEXT( "DepotIndex=" ), CmdDepotIndex );
	// %DEPOT_INDEX% - Index of the depot, when multiple processor are used.
	PathToChange.ReplaceInline( TEXT( "%DEPOT_INDEX%" ), *CmdDepotIndex );
}

bool ICrashDebugHelper::Init()
{
	bInitialized = true;

	// Check if we have a valid EngineVersion, if so use it.
	FString CmdEngineVersion;
	const bool bHasEngineVersion = FParse::Value( FCommandLine::Get(), TEXT( "EngineVersion=" ), CmdEngineVersion );
	if( bHasEngineVersion )
	{
		FEngineVersion EngineVersion;
		FEngineVersion::Parse( CmdEngineVersion, EngineVersion );

		// Clean branch name.
		CrashInfo.DepotName = EngineVersion.GetBranch();
		CrashInfo.BuiltFromCL = (int32)EngineVersion.GetChangelist();

		CrashInfo.EngineVersion = CmdEngineVersion;
	}
	else
	{
		// Use the current values.
		const FEngineVersion& EngineVersion = FEngineVersion::Current();
		CrashInfo.DepotName = EngineVersion.GetBranch();
		CrashInfo.BuiltFromCL = (int32)EngineVersion.GetChangelist();
		CrashInfo.EngineVersion = EngineVersion.ToString();
	}

	UE_LOG( LogCrashDebugHelper, Log, TEXT( "DepotName: %s" ), *CrashInfo.DepotName );
	UE_LOG( LogCrashDebugHelper, Log, TEXT( "BuiltFromCL: %i" ), CrashInfo.BuiltFromCL );
	UE_LOG( LogCrashDebugHelper, Log, TEXT( "EngineVersion: %s" ), *CrashInfo.EngineVersion );
	
	GConfig->GetString( TEXT( "Engine.CrashDebugHelper" ), TEXT( "SourceControlBuildLabelPattern" ), SourceControlBuildLabelPattern, GEngineIni );

	FCrashDebugHelperConfig::Get().ReadFullCrashDumpConfigurations();

	const bool bUsePDBCache = FCrashDebugHelperConfig::Get().IsValid();
	UE_CLOG( !bUsePDBCache, LogCrashDebugHelper, Warning, TEXT( "CrashDebugHelperConfig invalid" ) );

	if (bUsePDBCache)
	{
		FPDBCache::Get().Init();
	}
	else
	{
		UE_LOG( LogCrashDebugHelper, Warning, TEXT( "PDB Cache disabled" ) );
	}
	

	return bInitialized;
}

/** 
 * Initialise the source control interface, and ensure we have a valid connection
 */
bool ICrashDebugHelper::InitSourceControl(bool bShowLogin)
{
	// Ensure we are in a valid state to sync
	if (bInitialized == false)
	{
		UE_LOG(LogCrashDebugHelper, Warning, TEXT("InitSourceControl: CrashDebugHelper is not initialized properly."));
		return false;
	}

	// Initialize the source control if it hasn't already been
	if( !ISourceControlModule::Get().IsEnabled() || !ISourceControlModule::Get().GetProvider().IsAvailable() )
	{
		// make sure our provider is set to Perforce
		ISourceControlModule::Get().SetProvider("Perforce");

		// Attempt to load in a source control module
		ISourceControlModule::Get().GetProvider().Init();

#if !MINIDUMPDIAGNOSTICS
		if ((ISourceControlModule::Get().GetProvider().IsAvailable() == false) || bShowLogin)
		{
			// Unable to connect? Prompt the user for login information
			ISourceControlModule::Get().ShowLoginDialog(FSourceControlLoginClosed(), ELoginWindowMode::Modeless, EOnLoginWindowStartup::PreserveProvider);
		}
#endif
		// If it's still disabled, none was found, so exit
		if( !ISourceControlModule::Get().IsEnabled() || !ISourceControlModule::Get().GetProvider().IsAvailable() )
		{
			UE_LOG(LogCrashDebugHelper, Warning, TEXT("InitSourceControl: Source control unavailable or disabled."));
			return false;
		}
	}

	return true;
}

/** 
 * Shutdown the connection to source control
 */
void ICrashDebugHelper::ShutdownSourceControl()
{
	ISourceControlModule::Get().GetProvider().Close();
}


bool ICrashDebugHelper::SyncModules()
{
	// Check source control
	if( !ISourceControlModule::Get().IsEnabled() )
	{
		return false;
	}

	if( !FPDBCache::Get().UsePDBCache() )
	{
		UE_LOG( LogCrashDebugHelper, Warning, TEXT( "The PDB Cache is disabled, cannot proceed, %s" ), *CrashInfo.EngineVersion );
		return false;
	}

	// #CrashReport: 2015-02-23 Obsolete, remove after 4.8
	const TCHAR* UESymbols = TEXT( "Rocket/Symbols/" );
	const bool bHasExecutable = !CrashInfo.ExecutablesPath.IsEmpty();
	const bool bHasSymbols = !CrashInfo.SymbolsPath.IsEmpty();
	TArray< TSharedRef<ISourceControlLabel> > Labels = ISourceControlModule::Get().GetProvider().GetLabels( CrashInfo.LabelName );
	
	const bool bContainsProductVersion = FPDBCache::Get().ContainsPDBCacheEntry( CrashInfo.EngineVersion );
	if( bHasExecutable && bHasSymbols )
	{
		if( bContainsProductVersion )
		{
			UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Using cached storage: %s" ), *CrashInfo.EngineVersion );
			CrashInfo.PDBCacheEntry = FPDBCache::Get().FindAndTouchPDBCacheEntry( CrashInfo.EngineVersion );
		}
		else
		{
			SCOPE_LOG_TIME_IN_SECONDS( TEXT( "SyncExecutableAndSymbolsFromNetwork" ), nullptr );

			// Find all executables.
			TArray<FString> NetworkExecutables;

			// Don't duplicate work.
			if (CrashInfo.ExecutablesPath != CrashInfo.SymbolsPath)
			{
				IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.dll" ), true, false, false );
				IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.exe" ), true, false, false );
			}

			// Find all symbols.
			TArray<FString> NetworkSymbols;
			IFileManager::Get().FindFilesRecursive( NetworkSymbols, *CrashInfo.SymbolsPath, TEXT( "*.pdb" ), true, false, false );
			IFileManager::Get().FindFilesRecursive( NetworkSymbols, *CrashInfo.SymbolsPath, TEXT( "*.dll" ), true, false, false );
			IFileManager::Get().FindFilesRecursive( NetworkSymbols, *CrashInfo.SymbolsPath, TEXT( "*.exe" ), true, false, false );

			// From=Full pathname
			// To=Relative pathname
			TMap<FString, FString> FilesToBeCached;

			for( const auto& ExecutablePath : NetworkExecutables )
			{
				const FString NetworkRelativePath = ExecutablePath.Replace( *CrashInfo.ExecutablesPath, TEXT( "" ) );
				FilesToBeCached.Add( ExecutablePath, NetworkRelativePath );
			}

			for( const auto& SymbolPath : NetworkSymbols )
			{
				const FString SymbolRelativePath = SymbolPath.Replace( *CrashInfo.SymbolsPath, TEXT( "" ) );
				FilesToBeCached.Add( SymbolPath, SymbolRelativePath );
			}

			// Initialize and add a new PDB Cache entry to the database.
			CrashInfo.PDBCacheEntry = FPDBCache::Get().CreateAndAddPDBCacheEntryMixed( CrashInfo.EngineVersion, FilesToBeCached );
		}
	}
	// Get all labels associated with the crash info's label.
	// OBSOLETE PATH
	else if( Labels.Num() >= 1 )
	{
		TSharedRef<ISourceControlLabel> Label = Labels[0];
		TSet<FString> FilesToSync;

		// Use product version instead of label name to make a distinguish between chosen methods.
		const bool bContainsLabelName = FPDBCache::Get().ContainsPDBCacheEntry( CrashInfo.LabelName );

		if( bContainsProductVersion )
		{
			UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Using cached storage: %s" ), *CrashInfo.EngineVersion );
			CrashInfo.PDBCacheEntry = FPDBCache::Get().FindAndTouchPDBCacheEntry( CrashInfo.EngineVersion );
		}
		else if( bContainsLabelName )
		{
			UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Using cached storage: %s" ), *CrashInfo.LabelName );
			CrashInfo.PDBCacheEntry = FPDBCache::Get().FindAndTouchPDBCacheEntry( CrashInfo.LabelName );
		}
		else if( bHasExecutable )
		{			
			SCOPE_LOG_TIME_IN_SECONDS( TEXT( "SyncModulesAndNetwork" ), nullptr );

			// Grab information about symbols.
			TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > PDBSourceControlRevisions;
			const FString PDBsPath = FString::Printf( TEXT( "%s/%s....pdb" ), *CrashInfo.DepotName, UESymbols );
			Label->GetFileRevisions( PDBsPath, PDBSourceControlRevisions );

			TSet<FString> PDBPaths;
			for( const auto& PDBSrc : PDBSourceControlRevisions )
			{
				PDBPaths.Add( PDBSrc->GetFilename() );
			}

			// Now, sync symbols.
			for( const auto& PDBPath : PDBPaths )
			{
				if( Label->Sync( PDBPath ) )
				{
					UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Synced PDB: %s" ), *PDBPath );
				}
			}

			// Find all the executables in the product network path.
			TArray<FString> NetworkExecutables;
			IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.dll" ), true, false, false );
			IFileManager::Get().FindFilesRecursive( NetworkExecutables, *CrashInfo.ExecutablesPath, TEXT( "*.exe" ), true, false, false );

			// From=Full pathname
			// To=Relative pathname
			TMap<FString, FString> FilesToBeCached;

			// If a symbol matches an executable, add the pair to the list of files that should be cached.
			for( const auto& NetworkExecutableFullpath : NetworkExecutables )
			{
				for( const auto& PDBPath : PDBPaths )
				{
					const FString PDBRelativePath = PDBPath.Replace( *CrashInfo.DepotName, TEXT( "" ) ).Replace( UESymbols, TEXT( "" ) );
					const FString PDBFullpath = FPDBCache::Get().GetDepotRoot() / PDBPath;

					const FString PDBMatch = PDBRelativePath.Replace( TEXT( "pdb" ), TEXT( "" ) );
					const FString NetworkRelativePath = NetworkExecutableFullpath.Replace( *CrashInfo.ExecutablesPath, TEXT( "" ) );
					const bool bMatch = NetworkExecutableFullpath.Contains( PDBMatch );
					if( bMatch )
					{
						// From -> Where
						FilesToBeCached.Add( NetworkExecutableFullpath, NetworkRelativePath );
						FilesToBeCached.Add( PDBFullpath, PDBRelativePath );
						break;
					}
				}
			}

			// Initialize and add a new PDB Cache entry to the database.
			CrashInfo.PDBCacheEntry = FPDBCache::Get().CreateAndAddPDBCacheEntryMixed( CrashInfo.EngineVersion, FilesToBeCached );
		}
		else
		{
			TArray<FString> FilesToBeCached;
			
			//@TODO: MAC: Excluding labels for Mac since we are only syncing windows binaries here...
			if( Label->GetName().Contains( TEXT( "Mac" ) ) )
			{
				UE_LOG( LogCrashDebugHelper, Log, TEXT( "Skipping Mac label: %s" ), *Label->GetName() );
			}
			else
			{
				// Sync all the dll, exes, and related symbol files
				UE_LOG( LogCrashDebugHelper, Log, TEXT( "Syncing modules with label: %s" ), *Label->GetName() );

				SCOPE_LOG_TIME_IN_SECONDS( TEXT( "SyncModules" ), nullptr );

				// Grab all dll and pdb files for the specified label.
				TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > DLLSourceControlRevisions;
				const FString DLLsPath = FString::Printf( TEXT( "%s/....dll" ), *CrashInfo.DepotName );
				Label->GetFileRevisions( DLLsPath, DLLSourceControlRevisions );

				TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > EXESourceControlRevisions;
				const FString EXEsPath = FString::Printf( TEXT( "%s/....exe" ), *CrashInfo.DepotName );
				Label->GetFileRevisions( EXEsPath, EXESourceControlRevisions );

				TArray< TSharedRef<class ISourceControlRevision, ESPMode::ThreadSafe> > PDBSourceControlRevisions;
				const FString PDBsPath = FString::Printf( TEXT( "%s/....pdb" ), *CrashInfo.DepotName );
				Label->GetFileRevisions( PDBsPath, PDBSourceControlRevisions );

				TSet<FString> ModulesPaths;
				for( const auto& DLLSrc : DLLSourceControlRevisions )
				{
					ModulesPaths.Add( DLLSrc->GetFilename().Replace( *CrashInfo.DepotName, TEXT( "" ) ) );
				}
				for( const auto& EXESrc : EXESourceControlRevisions )
				{
					ModulesPaths.Add( EXESrc->GetFilename().Replace( *CrashInfo.DepotName, TEXT( "" ) ) );
				}

				TSet<FString> PDBPaths;
				for( const auto& PDBSrc : PDBSourceControlRevisions )
				{
					PDBPaths.Add( PDBSrc->GetFilename().Replace( *CrashInfo.DepotName, TEXT( "" ) ) );
				}

				// Iterate through all module and see if we have dll and pdb associated with the module, if so add it to the files to sync.
				for( const auto& ModuleName : CrashInfo.ModuleNames )
				{
					const FString ModuleNamePDB = ModuleName.Replace( TEXT( ".dll" ), TEXT( ".pdb" ) ).Replace( TEXT( ".exe" ), TEXT( ".pdb" ) );

					for( const auto& ModulePath : ModulesPaths )
					{
						const bool bContainsModule = ModulePath.Contains( ModuleName );
						if( bContainsModule )
						{
							FilesToSync.Add( ModulePath );
						}
					}

					for( const auto& PDBPath : PDBPaths )
					{
						const bool bContainsPDB = PDBPath.Contains( ModuleNamePDB );
						if( bContainsPDB )
						{
							FilesToSync.Add( PDBPath );
						}
					}
				}

				// Now, sync all files.
				for( const auto& Filename : FilesToSync )
				{
					const FString DepotPath = CrashInfo.DepotName + Filename;
					if( Label->Sync( DepotPath ) )
					{
						UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Synced binary: %s" ), *DepotPath );
					}
					FilesToBeCached.Add( DepotPath );
				}
			}

			// Initialize and add a new PDB Cache entry to the database.
			CrashInfo.PDBCacheEntry = FPDBCache::Get().CreateAndAddPDBCacheEntry( CrashInfo.LabelName, CrashInfo.DepotName, FilesToBeCached );
		}
	}
	// OBSOLETE PATH
	else
	{
		UE_LOG( LogCrashDebugHelper, Error, TEXT( "Could not find label: %s"), *CrashInfo.LabelName );
		return false;
	}

	return true;
}

bool ICrashDebugHelper::SyncSourceFile()
{
	// Check source control
	if( !ISourceControlModule::Get().IsEnabled() )
	{
		return false;
	}

	// Sync a single source file to requested CL.
	FString DepotPath = CrashInfo.DepotName / CrashInfo.SourceFile + TEXT( "@" ) + TTypeToString<int32>::ToString( CrashInfo.BuiltFromCL );
	ISourceControlModule::Get().GetProvider().Execute(ISourceControlOperation::Create<FSync>(), DepotPath);

	UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Syncing a single source file: %s"), *DepotPath );

	return true;
}


bool ICrashDebugHelper::ReadSourceFile( TArray<FString>& OutStrings )
{
	const bool bUsePDBCache = FPDBCache::Get().UsePDBCache();

	FString FilePath;
	if (bUsePDBCache)
	{
		// We assume a special folder for syncing all streams and //depot/ is not used in the view mapping.
		/*
			//depot/... //machine/... 
			//UE4/...	//machine/​​Stream/UE4/...​
		*/
		const TCHAR* DepotDelimiter = TEXT( "//depot/" );
		const bool bIsDepot = CrashInfo.DepotName.Contains( DepotDelimiter );

		if (bIsDepot)
		{
			FilePath = FPDBCache::Get().GetDepotRoot() / CrashInfo.DepotName.Replace( DepotDelimiter, TEXT( "" ) ) / CrashInfo.SourceFile;
		}
		else
		{
			FilePath = FPDBCache::Get().GetDepotRoot() / TEXT( "Stream" ) / CrashInfo.DepotName / CrashInfo.SourceFile;
			FilePath.ReplaceInline( TEXT( "//" ), TEXT( "/" ) );
		}
	}
	else
	{
		FilePath = FPaths::RootDir() / CrashInfo.SourceFile;
	}

	FString Line;
	if (FFileHelper::LoadFileToString( Line, *FilePath ))
	{
		Line = Line.Replace( TEXT( "\r" ), TEXT( "" ) );
		Line.ParseIntoArray( OutStrings, TEXT( "\n" ), false );
		UE_LOG( LogCrashDebugHelper, Log, TEXT( "Reading a single source file: %s" ), *FilePath );
		return true;
	}
	else
	{
		UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Failed to open source file: %s" ), *FilePath );
		return false;
	}
}

void ICrashDebugHelper::AddSourceToReport()
{
	if( CrashInfo.SourceFile.Len() > 0 && CrashInfo.SourceLineNumber != 0 )
	{
		TArray<FString> Lines;
		ReadSourceFile( Lines );

		const uint32 MinLine = FMath::Clamp( CrashInfo.SourceLineNumber - 15, (uint32)1, (uint32)Lines.Num() );
		const uint32 MaxLine = FMath::Clamp( CrashInfo.SourceLineNumber + 15, (uint32)1, (uint32)Lines.Num() );

		for( uint32 Line = MinLine; Line < MaxLine; Line++ )
		{
			if( Line == CrashInfo.SourceLineNumber - 1 )
			{
				CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u ***** %s" ), Line, *Lines[Line] ) );
			}
			else
			{
				CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u       %s" ), Line, *Lines[Line] ) );
			}
		}
	}
}

bool ICrashDebugHelper::AddAnnotatedSourceToReport()
{
	// Make sure we have a source file to interrogate
	if( CrashInfo.SourceFile.Len() > 0 && CrashInfo.SourceLineNumber != 0 && !CrashInfo.LabelName.IsEmpty() )
	{
		// Check source control
		if( !ISourceControlModule::Get().IsEnabled() )
		{
			return false;
		}

		// Ask source control to annotate the file for us
		FString DepotPath = CrashInfo.DepotName / CrashInfo.SourceFile;

		TArray<FAnnotationLine> Lines;
		SourceControlHelpers::AnnotateFile( ISourceControlModule::Get().GetProvider(), CrashInfo.BuiltFromCL, DepotPath, Lines );

		uint32 MinLine = FMath::Clamp( CrashInfo.SourceLineNumber - 15, (uint32)1, (uint32)Lines.Num() );
		uint32 MaxLine = FMath::Clamp( CrashInfo.SourceLineNumber + 15, (uint32)1, (uint32)Lines.Num() );

		// Display a source context in the report, and decorate each line with the last editor of the line
		for( uint32 Line = MinLine; Line < MaxLine; Line++ )
		{			
			if( Line == CrashInfo.SourceLineNumber )
			{
				CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u ***** %20s: %s" ), Line, *Lines[Line].UserName, *Lines[Line].Line ) );
			}
			else
			{
				CrashInfo.SourceContext.Add( FString::Printf( TEXT( "%5u       %20s: %s" ), Line, *Lines[Line].UserName, *Lines[Line].Line ) );
			}
		}
		return true;
	}

	return false;
}

void FCrashInfo::Log( FString Line )
{
	UE_LOG( LogCrashDebugHelper, Warning, TEXT("%s"), *Line );
	Report += Line + LINE_TERMINATOR;
}


const TCHAR* FCrashInfo::GetProcessorArchitecture( EProcessorArchitecture PA )
{
	switch( PA )
	{
	case PA_X86:
		return TEXT( "x86" );
	case PA_X64:
		return TEXT( "x64" );
	case PA_ARM:
		return TEXT( "ARM" );
	}

	return TEXT( "Unknown" );
}


int64 FCrashInfo::StringSize( const ANSICHAR* Line )
{
	int64 Size = 0;
	if( Line != nullptr )
	{
		while( *Line++ != 0 )
		{
			Size++;
		}
	}
	return Size;
}


void FCrashInfo::WriteLine( FArchive* ReportFile, const ANSICHAR* Line )
{
	if( Line != NULL )
	{
		int64 StringBytes = StringSize( Line );
		ReportFile->Serialize( ( void* )Line, StringBytes );
	}

	ReportFile->Serialize( TCHAR_TO_UTF8( LINE_TERMINATOR ), FCStringWide::Strlen(LINE_TERMINATOR) );
}


void FCrashInfo::GenerateReport( const FString& DiagnosticsPath )
{
	FArchive* ReportFile = IFileManager::Get().CreateFileWriter( *DiagnosticsPath );
	if( ReportFile != NULL )
	{
		FString Line;

		WriteLine( ReportFile, TCHAR_TO_UTF8( TEXT( "Generating report for minidump" ) ) );
		WriteLine( ReportFile );

		if ( EngineVersion.Len() > 0 )
		{
			Line = FString::Printf( TEXT( "Application version %s" ), *EngineVersion );
			WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		}
		else if( Modules.Num() > 0 )
		{
			Line = FString::Printf( TEXT( "Application version %d.%d.%d" ), Modules[0].Major, Modules[0].Minor, Modules[0].Patch );
			WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		}

		Line = FString::Printf( TEXT( " ... built from changelist %d" ), BuiltFromCL );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		if( LabelName.Len() > 0 )
		{
			Line = FString::Printf( TEXT( " ... based on label %s" ), *LabelName );
			WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		}
		WriteLine( ReportFile );

		Line = FString::Printf( TEXT( "OS version %d.%d.%d.%d" ), SystemInfo.OSMajor, SystemInfo.OSMinor, SystemInfo.OSBuild, SystemInfo.OSRevision );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );

		Line = FString::Printf( TEXT( "Running %d %s processors" ), SystemInfo.ProcessorCount, GetProcessorArchitecture( SystemInfo.ProcessorArchitecture ) );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );

		Line = FString::Printf( TEXT( "Exception was \"%s\"" ), *Exception.ExceptionString );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		WriteLine( ReportFile );

		Line = FString::Printf( TEXT( "Source context from \"%s\"" ), *SourceFile );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		WriteLine( ReportFile );

		Line = FString::Printf( TEXT( "<SOURCE START>" ) );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		for( int32 LineIndex = 0; LineIndex < SourceContext.Num(); LineIndex++ )
		{
			Line = FString::Printf( TEXT( "%s" ), *SourceContext[LineIndex] );
			WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		}
		Line = FString::Printf( TEXT( "<SOURCE END>" ) );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		WriteLine( ReportFile );

		Line = FString::Printf( TEXT( "<CALLSTACK START>" ) );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );

		for( int32 StackIndex = 0; StackIndex < Exception.CallStackString.Num(); StackIndex++ )
		{
			Line = FString::Printf( TEXT( "%s" ), *Exception.CallStackString[StackIndex] );
			WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		}

		Line = FString::Printf( TEXT( "<CALLSTACK END>" ) );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );
		WriteLine( ReportFile );

		Line = FString::Printf( TEXT( "%d loaded modules" ), Modules.Num() );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line ) );

		for( int32 ModuleIndex = 0; ModuleIndex < Modules.Num(); ModuleIndex++ )
		{
			FCrashModuleInfo& Module = Modules[ModuleIndex];

			FString ModuleDirectory = FPaths::GetPath(Module.Name);
			FString ModuleName = FPaths::GetBaseFilename( Module.Name, true ) + FPaths::GetExtension( Module.Name, true );

			FString ModuleDetail = FString::Printf( TEXT( "%40s" ), *ModuleName );
			FString Version = FString::Printf( TEXT( " (%d.%d.%d.%d)" ), Module.Major, Module.Minor, Module.Patch, Module.Revision );
			ModuleDetail += FString::Printf( TEXT( " %22s" ), *Version );
			ModuleDetail += FString::Printf( TEXT( " 0x%016x 0x%08x" ), Module.BaseOfImage, Module.SizeOfImage );
			ModuleDetail += FString::Printf( TEXT( " %s" ), *ModuleDirectory );

			WriteLine( ReportFile, TCHAR_TO_UTF8( *ModuleDetail ) );
		}

		WriteLine( ReportFile );

		// Write out the processor debugging log
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Report ) );

		Line = FString::Printf( TEXT( "Report end!" ) );
		WriteLine( ReportFile, TCHAR_TO_UTF8( *Line )  );

		ReportFile->Close();
		delete ReportFile;
	}
}

void ICrashDebugHelper::FindSymbolsAndBinariesStorage()
{
	CrashInfo.ExecutablesPath.Empty();
	CrashInfo.SymbolsPath.Empty();
	CrashInfo.LabelName.Empty();

	if( CrashInfo.BuiltFromCL == FCrashInfo::INVALID_CHANGELIST )
	{
		UE_LOG( LogCrashDebugHelper, Warning, TEXT( "Invalid parameters" ) );
		return;
	}

	UE_LOG( LogCrashDebugHelper, Log, TEXT( "Engine version: %s" ), *CrashInfo.EngineVersion );

	const FPDBCacheConfigEntry ConfigEntry = FCrashDebugHelperConfig::Get().GetCacheConfigEntryForBranch( CrashInfo.DepotName );
	FString ExecutablePathPattern = ConfigEntry.ExecutablePathPattern;
	FString SymbolPathPattern = ConfigEntry.SymbolPathPattern;

	if (!ExecutablePathPattern.IsEmpty() || !SymbolPathPattern.IsEmpty())
	{
		UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using branch: %s" ), *CrashInfo.DepotName );
	}
	else
	{
		UE_LOG( LogCrashDebugHelper, Log, TEXT( "Branch not found: %s" ), *CrashInfo.DepotName );
		return;
	}
	
	const FString StrENGINE_VERSION = CrashInfo.EngineVersion;
	const FString StrPLATFORM_NAME = TEXT( "" ); // Not implemented yet
	const FString StrOLD_ENGINE_VERSION = FString::Printf( TEXT( "%s-CL-%i" ), *CrashInfo.DepotName.Replace( TEXT( "+" ), TEXT( "/" ) ), CrashInfo.BuiltFromCL )
		.Replace( TEXT("/"), TEXT("+") );

	const FString TestExecutablesPath = ExecutablePathPattern
		.Replace( TEXT( "%ENGINE_VERSION%" ), *StrENGINE_VERSION )
		.Replace( TEXT( "%PLATFORM_NAME%" ), *StrPLATFORM_NAME )
		.Replace( TEXT( "%OLD_ENGINE_VERSION%" ), *StrOLD_ENGINE_VERSION );

	const FString TestSymbolsPath = SymbolPathPattern
		.Replace( TEXT( "%ENGINE_VERSION%" ), *StrENGINE_VERSION )
		.Replace( TEXT( "%PLATFORM_NAME%" ), *StrPLATFORM_NAME )
		.Replace( TEXT( "%OLD_ENGINE_VERSION%" ), *StrOLD_ENGINE_VERSION );

	// Try to find the network path by using the pattern supplied via ini.
	// If this step successes, we will grab the executable from the network path instead of P4.
	bool bFoundDirectory = false;
	
	bool bHasExecutables = false;
	if (!TestExecutablesPath.IsEmpty())
	{
		bHasExecutables = IFileManager::Get().DirectoryExists(*TestExecutablesPath);
	}
	bool bHasSymbols = false;
	if (!TestSymbolsPath.IsEmpty())
	{
		bHasSymbols = IFileManager::Get().DirectoryExists(*TestSymbolsPath);
	}

	if( bHasExecutables && bHasSymbols )
	{
		CrashInfo.ExecutablesPath = TestExecutablesPath;
		CrashInfo.SymbolsPath = TestSymbolsPath;
		bFoundDirectory = true;
		UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using path for executables and symbols: %s" ), *CrashInfo.ExecutablesPath );
	}
	else if( bHasExecutables )
	{
		CrashInfo.ExecutablesPath = TestExecutablesPath;
		UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using path for executables: %s" ), *CrashInfo.ExecutablesPath );
	}
	else
	{
		UE_LOG( LogCrashDebugHelper, Log, TEXT( "Path for executables not found: %s" ), *TestExecutablesPath );
	}
	

	// Try to find the label directly in source control by using the pattern supplied via ini.
	if( !bFoundDirectory && !SourceControlBuildLabelPattern.IsEmpty() )
	{	
		const FString ChangelistString = FString::Printf( TEXT( "%d" ), CrashInfo.BuiltFromCL );
		const FString LabelWithCL = SourceControlBuildLabelPattern.Replace( TEXT( "%CHANGELISTNUMBER%" ), *ChangelistString, ESearchCase::CaseSensitive );
		UE_LOG( LogCrashDebugHelper, Log, TEXT( "Label matching pattern: %s" ), *LabelWithCL );

		TArray< TSharedRef<ISourceControlLabel> > Labels = ISourceControlModule::Get().GetProvider().GetLabels( LabelWithCL );
		if( Labels.Num() > 0 )
		{
			const int32 LabelIndex = 0;
			CrashInfo.LabelName = Labels[LabelIndex]->GetName();;
		
			// If we found more than one label, warn about it and just use the first one
			if( Labels.Num() > 1 )
			{
				UE_LOG( LogCrashDebugHelper, Warning, TEXT( "More than one build label found, using label: %s" ), *LabelWithCL, *CrashInfo.LabelName );
			}
			else
			{
				UE_LOG( LogCrashDebugHelper, Log, TEXT( "Using label: %s" ), *CrashInfo.LabelName );
			}		
		}
	}
}