/// <summary> /// Processes the specified type's fields to fill in required data. /// </summary> /// <param name="TheLibrary">The library from which the type originated.</param> /// <param name="theTypeInfo">The type info to process.</param> public static void ProcessTypeFields(IL.ILLibrary TheLibrary, TypeInfo theTypeInfo) { if (theTypeInfo.ProcessedFields) { return; } theTypeInfo.ProcessedFields = true; int totalOffset = 0; //Base class fields if (theTypeInfo.UnderlyingType.BaseType != null) { Type baseType = theTypeInfo.UnderlyingType.BaseType; if (!baseType.AssemblyQualifiedName.Contains("mscorlib")) { totalOffset = TheLibrary.GetTypeInfo(baseType).SizeOnHeapInBytes; } } foreach (FieldInfo aFieldInfo in theTypeInfo.FieldInfos) { if (!aFieldInfo.IsStatic) { aFieldInfo.OffsetInBytes = totalOffset; TypeInfo fieldTypeInfo = TheLibrary.GetTypeInfo(aFieldInfo.FieldType); totalOffset += fieldTypeInfo.IsValueType ? fieldTypeInfo.SizeOnHeapInBytes : fieldTypeInfo.SizeOnStackInBytes; } } }
/// <summary> /// Processes the specified type info to fill in the required data. /// </summary> /// <param name="TheLibrary">The library from which the type originated.</param> /// <param name="theTypeInfo">The type info to process.</param> public static void ProcessType(IL.ILLibrary TheLibrary, TypeInfo theTypeInfo) { if (theTypeInfo.Processed) { return; } theTypeInfo.Processed = true; theTypeInfo.IsGCManaged = GetIsGCManaged(theTypeInfo.UnderlyingType); if (theTypeInfo.IsValueType || theTypeInfo.IsPointer) { theTypeInfo.SizeOnStackInBytes = GetSizeOnStackInBytes(theTypeInfo.UnderlyingType); theTypeInfo.SizeOnHeapInBytes = GetSizeOnHeapInBytes(theTypeInfo.UnderlyingType); } else { theTypeInfo.SizeOnStackInBytes = GetSizeOnStackInBytes(theTypeInfo.UnderlyingType); theTypeInfo.SizeOnHeapInBytes = 0; if (theTypeInfo.UnderlyingType.BaseType != null) { Type baseType = theTypeInfo.UnderlyingType.BaseType; if (!baseType.AssemblyQualifiedName.Contains("mscorlib")) { TypeInfo baseTypeInfo = TheLibrary.GetTypeInfo(baseType, false); ProcessType(TheLibrary, baseTypeInfo); theTypeInfo.SizeOnHeapInBytes += baseTypeInfo.SizeOnHeapInBytes; } } foreach (FieldInfo aFieldInfo in theTypeInfo.FieldInfos) { if (!aFieldInfo.IsStatic) { TypeInfo fieldTypeInfo = TheLibrary.GetTypeInfo(aFieldInfo.FieldType, false); if (fieldTypeInfo.IsValueType || fieldTypeInfo.IsPointer) { ProcessType(TheLibrary, fieldTypeInfo); } theTypeInfo.SizeOnHeapInBytes += fieldTypeInfo.IsValueType ? fieldTypeInfo.SizeOnHeapInBytes : Options.AddressSizeInBytes; } } } }
/// <summary> /// Compiles the specified IL Library and any dependencies using the ASM Preprocesor and ASM Processor. /// </summary> /// <remarks> /// The ASM Compiler's steps convert the ASM into machine code. /// </remarks> /// <param name="TheILLibrary">The library to compile.</param> /// <returns>CompileResult.OK if all steps complete successfully.</returns> public static CompileResult Compile(IL.ILLibrary TheILLibrary) { CompileResult Result = CompileResult.OK; foreach (IL.ILLibrary depLib in TheILLibrary.Dependencies) { Result = Result == CompileResult.OK ? Compile(depLib) : Result; } Result = Result == CompileResult.OK ? ExecuteASMPreprocessor(TheILLibrary.TheASMLibrary) : Result; if (Result == CompileResult.OK) { Result = ExecuteASMProcessor(TheILLibrary.TheASMLibrary); } return(Result); }
/// <summary> /// Scans the library for types. /// </summary> /// <param name="TheLibrary">The library to scan.</param> public static void ScanTypes(IL.ILLibrary TheLibrary) { if (TheLibrary == null) { return; } else if (TheLibrary.TypeInfos.Count != 0) { //Already scanned return; } foreach (IL.ILLibrary aDependency in TheLibrary.Dependencies) { ScanTypes(aDependency); } List <Type> types = TheLibrary.TheAssembly.GetTypes().ToList(); //Add in the standard types (which come from mscorlib) //#region Standard Types (from mscorlib) //types.Add(typeof(object)); //types.Add(typeof(float)); //types.Add(typeof(double)); //types.Add(typeof(decimal)); //types.Add(typeof(string)); //types.Add(typeof(IntPtr)); //types.Add(typeof(void)); //types.Add(typeof(bool)); //types.Add(typeof(byte)); //types.Add(typeof(sbyte)); //types.Add(typeof(char)); //types.Add(typeof(int)); //types.Add(typeof(long)); //types.Add(typeof(Int16)); //types.Add(typeof(Int32)); //types.Add(typeof(Int64)); //types.Add(typeof(UInt16)); //types.Add(typeof(UInt32)); //types.Add(typeof(UInt64)); //types.Add(typeof(void*)); //types.Add(typeof(bool*)); //types.Add(typeof(byte*)); //types.Add(typeof(sbyte*)); //types.Add(typeof(char*)); //types.Add(typeof(int*)); //types.Add(typeof(long*)); //types.Add(typeof(Int16*)); //types.Add(typeof(Int32*)); //types.Add(typeof(Int64*)); //types.Add(typeof(UInt16*)); //types.Add(typeof(UInt32*)); //types.Add(typeof(UInt64*)); //#endregion foreach (Type aType in types) { ScanType(TheLibrary, aType); } for (int i = 0; i < TheLibrary.TypeInfos.Count; i++) { ProcessType(TheLibrary, TheLibrary.TypeInfos[i]); } for (int i = 0; i < TheLibrary.TypeInfos.Count; i++) { ProcessTypeFields(TheLibrary, TheLibrary.TypeInfos[i]); } }
/// <summary> /// Scans a type to generate type info for the type. Also scans methods and constructors of the type /// amongst some other information. /// </summary> /// <param name="TheLibrary">The library from which the type originated.</param> /// <param name="aType">The type to scan.</param> /// <returns>The new type info.</returns> public static TypeInfo ScanType(IL.ILLibrary TheLibrary, Type aType) { if (TheLibrary.TypeInfos.Where(x => x.UnderlyingType.Equals(aType)).Count() > 0) { return(TheLibrary.TypeInfos.Where(x => x.UnderlyingType.Equals(aType)).First()); } string typeName = aType.Name; TypeInfo newTypeInfo = new TypeInfo() { UnderlyingType = aType }; TheLibrary.TypeInfos.Add(newTypeInfo); { object[] CustAttrs = aType.GetCustomAttributes(false); foreach (object aCustAttr in CustAttrs) { if (!aCustAttr.GetType().AssemblyQualifiedName.Contains("mscorlib")) { if (!IL.ILLibrary.SpecialClasses.ContainsKey(aCustAttr.GetType())) { IL.ILLibrary.SpecialClasses.Add(aCustAttr.GetType(), new List <TypeInfo>()); } IL.ILLibrary.SpecialClasses[aCustAttr.GetType()].Add(newTypeInfo); } } } //Ignore all internal data of types from mscorlib except for value types such as // int, uint etc. and associated pointer types if (!aType.AssemblyQualifiedName.Contains("mscorlib")) { // All Fields System.Reflection.FieldInfo[] allFields = aType.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public); foreach (System.Reflection.FieldInfo aFieldInfo in allFields) { if (aFieldInfo.DeclaringType.Equals(newTypeInfo.UnderlyingType)) { newTypeInfo.FieldInfos.Add(new FieldInfo() { UnderlyingInfo = aFieldInfo }); } } // Plugged / Unplugged Methods System.Reflection.MethodInfo[] allMethods = aType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static).ToArray(); foreach (System.Reflection.MethodInfo aMethodInfo in allMethods) { if (aMethodInfo.DeclaringType.Equals(aType)) { MethodInfo newMethodInfo = new MethodInfo() { UnderlyingInfo = aMethodInfo, PlugAttribute = (Attributes.PluggedMethodAttribute)aMethodInfo.GetCustomAttribute(typeof(Attributes.PluggedMethodAttribute)) }; newTypeInfo.MethodInfos.Add(newMethodInfo); object[] CustAttrs = aMethodInfo.GetCustomAttributes(false); foreach (object aCustAttr in CustAttrs) { if (!aCustAttr.GetType().AssemblyQualifiedName.Contains("mscorlib")) { if (!IL.ILLibrary.SpecialMethods.ContainsKey(aCustAttr.GetType())) { IL.ILLibrary.SpecialMethods.Add(aCustAttr.GetType(), new List <MethodInfo>()); } IL.ILLibrary.SpecialMethods[aCustAttr.GetType()].Add(newMethodInfo); } } } } // Plugged / unplugged Constructors ConstructorInfo[] allConstructors = aType.GetConstructors(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) .ToArray(); foreach (ConstructorInfo aConstructorInfo in allConstructors) { if (aConstructorInfo.DeclaringType.Equals(aType)) { MethodInfo newMethodInfo = new MethodInfo() { UnderlyingInfo = aConstructorInfo, PlugAttribute = (Attributes.PluggedMethodAttribute)aConstructorInfo.GetCustomAttribute(typeof(Attributes.PluggedMethodAttribute)) }; newTypeInfo.MethodInfos.Add(newMethodInfo); object[] CustAttrs = aConstructorInfo.GetCustomAttributes(false); foreach (object aCustAttr in CustAttrs) { if (!aCustAttr.GetType().AssemblyQualifiedName.Contains("mscorlib")) { if (!IL.ILLibrary.SpecialMethods.ContainsKey(aCustAttr.GetType())) { IL.ILLibrary.SpecialMethods.Add(aCustAttr.GetType(), new List <MethodInfo>()); } IL.ILLibrary.SpecialMethods[aCustAttr.GetType()].Add(newMethodInfo); } } } } } return(newTypeInfo); }
public override bool LinkISO(IL.ILLibrary TheLibrary, LinkInformation LinkInfo) { bool OK = true; string BinPath = LinkInfo.ISOPath.Replace(".iso", ".bin"); string ElfPath = LinkInfo.ISOPath.Replace(".iso", ".elf"); StreamWriter ASMWriter = new StreamWriter(LinkInfo.ASMPath, false); StringBuilder CommandLineArgsBuilder = new StringBuilder(); CommandLineArgsBuilder.Append("--fatal-warnings -EL -Os -T \"" + LinkInfo.LinkScriptPath + "\" -o \"" + ElfPath + "\""); StringBuilder LinkScript = new StringBuilder(); LinkScript.Append(@"ENTRY(Kernel_Start) OUTPUT_ARCH(mips) SECTIONS { . = 0x" + Options.BaseAddress.ToString("X8") + @"; .text : AT(ADDR(.text) - " + Options.LoadOffset.ToString() + @") { "); for (int i = 0; i < LinkInfo.SequencedASMBlocks.Count; i++) { LinkScript.AppendLine(string.Format(" \"{0}\" (.text);", LinkInfo.SequencedASMBlocks[i].ObjectOutputFilePath)); ASMWriter.WriteLine(File.ReadAllText(LinkInfo.SequencedASMBlocks[i].ASMOutputFilePath)); } LinkScript.AppendLine(@" * (.text); } . = ALIGN(0x4); .data : AT(ADDR(.data) - " + Options.LoadOffset.ToString() + @") { * (.data*); } . = ALIGN(0x4); .bss : AT(ADDR(.bss) - " + Options.LoadOffset.ToString() + @") { * (.bss*); } } "); ASMWriter.Close(); File.WriteAllText(LinkInfo.LinkScriptPath, LinkScript.ToString()); OK = Utilities.ExecuteProcess(LinkInfo.LdWorkingDir, Path.Combine(LinkInfo.ToolsPath, @"MIPS\mips-linux-gnu-ld.exe"), CommandLineArgsBuilder.ToString(), "Ld"); if (OK) { if (File.Exists(BinPath)) { File.Delete(BinPath); } OK = Utilities.ExecuteProcess(Options.OutputPath, Path.Combine(LinkInfo.ToolsPath, @"MIPS\mips-linux-gnu-objcopy.exe"), string.Format("-O binary \"{0}\" \"{1}\"", ElfPath, BinPath), "MIPS:ObjCopy"); if (OK) { if (File.Exists(LinkInfo.MapPath)) { File.Delete(LinkInfo.MapPath); } OK = Utilities.ExecuteProcess(Options.OutputPath, Path.Combine(LinkInfo.ToolsPath, @"MIPS\mips-linux-gnu-objdump.exe"), string.Format("--wide --syms \"{0}\"", ElfPath), "MIPS:ObjDump", false, LinkInfo.MapPath); } } return(OK); }
public override bool LinkELF(IL.ILLibrary TheLibrary, LinkInformation LinkInfo) { return(false); }
/// <summary> /// Executes the Drivers Compiler using the specified logging methods. /// </summary> /// <param name="messageHandler">The handler for outputting ordinary messages.</param> /// <param name="warningHandler">The handler for outputting warning messages.</param> /// <param name="errorHandler">The handler for outputting error messages.</param> /// <returns>Returns an error code.</returns> public static ErrorCode Execute( Logger.LogMessageEventHandler messageHandler, Logger.LogWarningEventHandler warningHandler, Logger.LogErrorEventHandler errorHandler) { ErrorCode result = ErrorCode.NoError; Logger.OnLogMessage += messageHandler; Logger.OnLogWarning += warningHandler; Logger.OnLogError += errorHandler; Options.Format(); DateTime startTime = DateTime.Now; Logger.LogMessage("", 0, "Driver compiler started @ " + startTime.ToLongTimeString()); Logger.LogMessage("", 0, "Library path = \"" + Options.LibraryPath + "\""); Logger.LogMessage("", 0, "Output path = \"" + Options.OutputPath + "\""); Logger.LogMessage("", 0, "Tools path = \"" + Options.ToolsPath + "\""); Logger.LogMessage("", 0, "Target architecture = \"" + Options.TargetArchitecture + "\""); Logger.LogMessage("", 0, "Build mode = " + Enum.GetName(typeof(Options.BuildModes), Options.BuildMode)); Logger.LogMessage("", 0, "Link mode = " + Enum.GetName(typeof(Options.LinkModes), Options.LinkMode)); Logger.LogMessage("", 0, "Base address = " + Options.BaseAddress.ToString()); Logger.LogMessage("", 0, "Load offset = " + Options.LoadOffset.ToString()); // IL Library - In a list of libraries returned to the higher-level control app (this app) // from Library Loader // : Type Info - In a list of types in the IL Library // : Field Info - In a list of static and non-static fields in the Type Info // : Method Info - In a list of methods in the Type Info // : Variable Info - In a list of variables in the Method Info // : IL Block - In a list of blocks in the IL Library and held against the origin Method Info // : IL Op - In a list of ops in the IL Block // // ASM Library - In a list of libraries returned to the higher-level control app (this app) // from IL Compiler // : ASM Block - In a list of blocks in the ASM Library and held against the origin IL Block // : ASM Op - In a list of ops in the ASM Block // // Options - Compiler options used throughout the compiler // Library loader - Loads IL Libraries to be compiled // - Type Scanner - Loads all the Type Infos, Field Infos and Method Infos. // IL Compiler - Manages the IL compile stage // - IL Reader - Loads IL ops from IL Methods in IL Types. Also loads plug info. // - IL Preprocessor - Pre-scans IL ops to find things like necessary branching labels. // Also handles injecting any necessary IL ops in such a way that // IL integrity is maintained. // - IL Scanner - Converts IL ops to ASM ops // ASM Compiler - Manages the ASM compile stage // - ASM Preprocessor - Pre-scans the ASM ops to store things like debug info or perform // optimisation // - ASM Processor - Converts ASM ops into ASM text then runs the assembly code compiler (e.g. NASM) // Link Manager - Manages the linker stage. Links together all the object files using "ld". // To think about: // - Try-catch-finally blocks // - GC (inc. wrapping try-finally, calls to inc/dec) // - Release / Debug IL (differences? Potential issues?) // Resultant thoughts from above: // - IL labels based on IL Op index NOT IL op offset // - IL Preprocessor handle injecting any IL ops inc. try-catch-finally, GC stuff and special // class / method stuff (e.g. static variables, static constructors etc.) // - IL Preprocessor needs to maintain the integrity of the IL so that no assumption are made // so that Release mode IL also works // TODO: // - Check for unchanged methods (in IL Preprocessor) and exclude them from recompile Tuple <bool, string> ValidateOptions_Result = Options.Validate(); if (ValidateOptions_Result.Item1) { try { TargetArchitecture.Init(); IL.ILLibrary TheLibrary = LibraryLoader.LoadILLibrary(Options.LibraryPath); CompileResult ILCompileResult = IL.ILCompiler.Compile(TheLibrary); if (ILCompileResult == CompileResult.OK || ILCompileResult == CompileResult.PartialFailure) { CompileResult ASMCompileResult = ASM.ASMCompiler.Compile(TheLibrary); if (ASMCompileResult == CompileResult.OK) { CompileResult LinkResult = LinkManager.Link(TheLibrary); if (LinkResult == CompileResult.OK) { if (ILCompileResult == CompileResult.PartialFailure) { result = ErrorCode.ILCompilerFailed; } //Success Logger.LogMessage("", 0, "Compilation succeeded."); } else { //Fail Logger.LogError(Errors.Linker_LinkFailed_ErrorCode, "", 0, Errors.ErrorMessages[Errors.Linker_LinkFailed_ErrorCode]); result = ErrorCode.LinkerFailed; } } else { //Fail Logger.LogError(Errors.ASMCompiler_CompileFailed_ErrorCode, "", 0, Errors.ErrorMessages[Errors.ASMCompiler_CompileFailed_ErrorCode]); result = ErrorCode.ASMCompilerFailed; } } else { //Fail Logger.LogError(Errors.ILCompiler_CompileFailed_ErrorCode, "", 0, Errors.ErrorMessages[Errors.ILCompiler_CompileFailed_ErrorCode]); result = ErrorCode.ILCompilerFailed; } } catch (NullReferenceException ex) { Logger.LogError(Errors.ILCompiler_NullRefException_ErrorCode, "", 0, string.Format( Errors.ErrorMessages[Errors.ILCompiler_NullRefException_ErrorCode], ex.Message, ex.StackTrace)); result = ErrorCode.ILCompilerFailed; } catch (Exception ex) { Logger.LogError(Errors.ILCompiler_UnexpectedException_ErrorCode, "", 0, string.Format( Errors.ErrorMessages[Errors.ILCompiler_UnexpectedException_ErrorCode], ex.Message, ex.StackTrace)); result = ErrorCode.ILCompilerFailed; } } else { //Fail Logger.LogError(Errors.PreReqs_OptionsInvalid_ErrorCode, "", 0, string.Format( Errors.ErrorMessages[Errors.PreReqs_OptionsInvalid_ErrorCode], ValidateOptions_Result.Item2)); result = ErrorCode.InvalidOptions; } DateTime endTime = DateTime.Now; Logger.LogMessage("", 0, "Driver compiler finished @ " + endTime.ToLongTimeString()); Logger.LogMessage("", 0, " Compile time : " + (endTime - startTime).ToString()); Logger.LogMessage("", 0, " Error code : " + System.Enum.GetName(typeof(ErrorCode), result)); return(result); }
public override bool LinkELF(IL.ILLibrary TheLibrary, LinkInformation LinkInfo) { StringBuilder CommandLineArgsBuilder = new StringBuilder(); if (!LinkInfo.ExecutableOutput) { CommandLineArgsBuilder.Append("-shared "); } CommandLineArgsBuilder.Append("-L .\\Output -T \"" + LinkInfo.LinkScriptPath + "\" -o \"" + LinkInfo.BinPath + "\""); StreamWriter ASMWriter = new StreamWriter(LinkInfo.ASMPath, false); StringBuilder LinkScript = new StringBuilder(); LinkScript.Append((LinkInfo.ExecutableOutput ? "ENTRY(" + LinkInfo.EntryPoint + ")\r\n" : "") + @"GROUP("); LinkScript.Append(string.Join(" ", LinkInfo.SequencedASMBlocks .Where(x => File.Exists(x.ObjectOutputFilePath)) .Select(x => "\"" + x.ObjectOutputFilePath + "\""))); LinkScript.Append(@") "); if (LinkInfo.depLibNames.Count > 0) { LinkScript.Append("GROUP("); LinkScript.Append(string.Join(" ", LinkInfo.depLibNames.Select(x => "-l" + x))); LinkScript.Append(")"); } LinkScript.AppendLine(@" SECTIONS { . = 0x" + (0x40000000 + (LinkInfo.depLibNames.Count * 0x1000)).ToString("X2") + @"; .text : { "); for (int i = 0; i < LinkInfo.SequencedASMBlocks.Count; i++) { LinkScript.AppendLine(string.Format(" \"{0}\" (.text);", LinkInfo.SequencedASMBlocks[i].ObjectOutputFilePath)); ASMWriter.WriteLine(File.ReadAllText(LinkInfo.SequencedASMBlocks[i].ASMOutputFilePath)); } LinkScript.AppendLine(@" * (.text); * (.rodata*); } . = ALIGN(0x1000); .data : AT(ADDR(.data)) { * (.data*); } . = ALIGN(0x1000); .bss : AT(ADDR(.bss)) { * (.bss*); } } "); ASMWriter.Close(); File.WriteAllText(LinkInfo.LinkScriptCmdPath, CommandLineArgsBuilder.ToString()); File.WriteAllText(LinkInfo.LinkScriptPath, LinkScript.ToString()); return(Utilities.ExecuteProcess(LinkInfo.LdWorkingDir, Path.Combine(LinkInfo.ToolsPath, @"Cygwin\ld.exe"), CommandLineArgsBuilder.ToString(), "Ld")); }
public override bool LinkISO(IL.ILLibrary TheLibrary, LinkInformation LinkInfo) { bool OK = true; StreamWriter ASMWriter = new StreamWriter(LinkInfo.ASMPath, false); StringBuilder CommandLineArgsBuilder = new StringBuilder(); CommandLineArgsBuilder.Append("--fatal-warnings -T \"" + LinkInfo.LinkScriptPath + "\" -o \"" + LinkInfo.BinPath + "\""); StringBuilder LinkScript = new StringBuilder(); LinkScript.Append(@"ENTRY(Kernel_Start) OUTPUT_FORMAT(elf32-i386) GROUP("); LinkScript.Append(string.Join(" ", LinkInfo.SequencedASMBlocks .Where(x => File.Exists(x.ObjectOutputFilePath)) .Select(x => "\"" + x.ObjectOutputFilePath + "\""))); LinkScript.AppendLine(@") SECTIONS { /* The kernel will live at 3GB + 1MB in the virtual address space, which will be mapped to 1MB in the physical address space. */ . = 0x" + Options.BaseAddress.ToString("X8") + @"; .text : AT(ADDR(.text) - " + Options.LoadOffset.ToString() + @") { "); for (int i = 0; i < LinkInfo.SequencedASMBlocks.Count; i++) { LinkScript.AppendLine(string.Format(" \"{0}\" (.text);", LinkInfo.SequencedASMBlocks[i].ObjectOutputFilePath)); ASMWriter.WriteLine(File.ReadAllText(LinkInfo.SequencedASMBlocks[i].ASMOutputFilePath)); } LinkScript.AppendLine(@" * (.text); * (.rodata*); } . = ALIGN(0x1000); .data : AT(ADDR(.data) - " + Options.LoadOffset.ToString() + @") { * (.data*); } . = ALIGN(0x1000); .bss : AT(ADDR(.bss) - " + Options.LoadOffset.ToString() + @") { * (.bss*); } } "); ASMWriter.Close(); File.WriteAllText(LinkInfo.LinkScriptPath, LinkScript.ToString()); OK = Utilities.ExecuteProcess(LinkInfo.LdWorkingDir, Path.Combine(LinkInfo.ToolsPath, @"Cygwin\ld.exe"), CommandLineArgsBuilder.ToString(), "Ld"); if (OK) { if (File.Exists(LinkInfo.ISOPath)) { File.Delete(LinkInfo.ISOPath); } OK = Utilities.ExecuteProcess(Options.OutputPath, LinkInfo.ISOGenPath, string.Format("4 \"{0}\" \"{1}\" true \"{2}\"", LinkInfo.ISOPath, LinkInfo.ISOLinuxPath, LinkInfo.ISODirPath), "ISO9660Generator"); if (OK) { if (File.Exists(LinkInfo.MapPath)) { File.Delete(LinkInfo.MapPath); } OK = Utilities.ExecuteProcess(Options.OutputPath, Path.Combine(LinkInfo.ToolsPath, @"Cygwin\objdump.exe"), string.Format("--wide --syms \"{0}\"", LinkInfo.BinPath), "ObjDump", false, LinkInfo.MapPath); } } return(OK); }