void SetJITCompilerFlags() { if (Process.DebugMode != DebugModeFlag.Default) { // translate DebugModeFlags to JITCompilerFlags CorDebugJITCompilerFlags jcf = MapDebugModeToJITCompilerFlags(Process.DebugMode); try { this.JITCompilerFlags = jcf; // Flags may succeed but not set all bits, so requery. CorDebugJITCompilerFlags jcfActual = this.JITCompilerFlags; #if DEBUG if (jcf != jcfActual) { Console.WriteLine("Couldn't set all flags. Actual flags:" + jcfActual.ToString()); } else { Console.WriteLine("Actual flags:" + jcfActual.ToString()); } #endif } catch (COMException ex) { // we'll ignore the error if we cannot set the jit flags Console.WriteLine(string.Format("Failed to set flags with hr=0x{0:x}", ex.ErrorCode)); } } }
/// <summary> /// Gets the current compiler flag settings that the common language runtime /// (CLR) uses to select the correct precompiled (that is, native) image to /// be loaded into this process. /// </summary> /// <remarks> /// Use the <see cref="SetDesiredNGENCompilerFlags(CorDebugJITCompilerFlags)" /> /// method to set the flags that the CLR will use to select the correct /// pre-compiled image to load. /// </remarks> public unsafe int GetDesiredNGENCompilerFlags(out CorDebugJITCompilerFlags pdwFlags) { uint flags = default; int hResult = Calli(_this, This[0]->GetDesiredNGENCompilerFlags, &flags); pdwFlags = (CorDebugJITCompilerFlags)flags; return(hResult); }
void SetJITCompilerFlags() { // ad CORDEBUG_JIT_ENABLE_ENC: // see issue #553 on GitHub: "ExecutionEngineException or AccessViolationException (CLR 2.0) // when debugging a program that uses System.Data.OleDb" // System.Data.dll (partially) is a C++/CLI assembly and EnC is not supported there. // trying to set CORDEBUG_JIT_ENABLE_ENC succeeds at first, but leads to strange exceptions afterwards. // CORDEBUG_JIT_ENABLE_ENC should only be set for managed-only modules with User Code. CorDebugJITCompilerFlags flags; if (this.Process.Options.SuppressJITOptimization) { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DISABLE_OPTIMIZATION; } else { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT; } try { this.JITCompilerFlags = flags; } catch (COMException ex) { Console.WriteLine(string.Format("Failed to set flags with hr=0x{0:x}", ex.ErrorCode)); } CorDebugJITCompilerFlags actual = this.JITCompilerFlags; if (flags != actual) { this.Process.TraceMessage("Couldn't set JIT flags to {0}. Actual flags: {1}", flags, actual); } else { this.Process.TraceMessage("JIT flags: {0}", actual); } }
void SetJITCompilerFlags() { CorDebugJITCompilerFlags flags; if (this.Process.Options.EnableEditAndContinue) { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_ENABLE_ENC; } else if (this.Process.Options.SuppressJITOptimization) { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DISABLE_OPTIMIZATION; } else { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT; } try { this.JITCompilerFlags = flags; } catch (COMException ex) { Console.WriteLine(string.Format("Failed to set flags with hr=0x{0:x}", ex.ErrorCode)); } CorDebugJITCompilerFlags actual = this.JITCompilerFlags; if (flags != actual) { this.Process.TraceMessage("Couldn't set JIT flags to {0}. Actual flags: {1}", flags, actual); } else { this.Process.TraceMessage("JIT flags: {0}", actual); } }
void SetJITCompilerFlags() { CorDebugJITCompilerFlags flags; if (this.Process.Options.EnableEditAndContinue) { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_ENABLE_ENC; } else if (this.Process.Options.SuppressJITOptimization) { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DISABLE_OPTIMIZATION; } else { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT; } try { this.JITCompilerFlags = flags; } catch (COMException ex) { Console.WriteLine(string.Format("Failed to set flags with hr=0x{0:x}", ex.ErrorCode)); } CorDebugJITCompilerFlags actual = this.JITCompilerFlags; if (flags != actual) this.Process.TraceMessage("Couldn't set JIT flags to {0}. Actual flags: {1}", flags, actual); else this.Process.TraceMessage("JIT flags: {0}", actual); }
internal void InitializeCachedValues() { // Cache the value so it's possible to read it even when the process is running CachedJITCompilerFlags = CorModule.JITCompilerFlags; }
/// <summary> /// Sets the flags that must be embedded in a precompiled image in order for /// the runtime to load that image into the current process. /// </summary> /// <param name="pdwFlags"></param> /// <returns></returns> /// <remarks> /// This method specifies the flags that must be embedded in a precompiled /// image so that the runtime will load that image into this process. The /// flags set by this method are used only to select the correct precompiled /// image. If no such image exists, the runtime will load the Microsoft /// intermediate language (MSIL) image and the just-in-time (JIT) compiler /// instead. In that case, the debugger must still use the /// <see cref="CorDebugModule2.SetJITCompilerFlags" /> method to set the flags /// as desired for the JIT compilation. /// /// If an image is loaded, but some JIT compiling must take place for that image /// (which will be the case if the image contains generics), the compiler flags /// specified by this method will apply to the extra JIT compilation. /// /// This method must be called during the <c>ICorDebugManagedCallback::CreateProcess</c> /// callback. Attempts to call the it afterwards will fail. Also, attempts to set /// flags that are either not defined in the <see cref="CorDebugJITCompilerFlags" /> /// enumeration or are not legal for the given process will fail. /// </remarks> public unsafe int SetDesiredNGENCompilerFlags(CorDebugJITCompilerFlags pdwFlags) => Calli(_this, This[0]->SetDesiredNGENCompilerFlags, (uint)pdwFlags);
// Populate the module window with the current list. // Called on UI thread. protected override void RefreshToolWindowInternal() { ListView.ListViewItemCollection items = listView1.Items; items.Clear(); ListViewItem[] temp = null; // Go to worker thread to collect information MainForm.ExecuteOnWorkerThreadIfStoppedAndBlock(delegate(MDbgProcess proc) { Debug.Assert(proc != null); Debug.Assert(!proc.IsRunning); temp = new ListViewItem[proc.Modules.Count]; int idx = 0; foreach (MDbgModule m in proc.Modules) { var sbFlags = new StringBuilder(); if (m.SymReader == null) { sbFlags.Append("[No symbols]"); } else { sbFlags.Append("[Symbols]"); } string fullname = m.CorModule.Name; string directory = Path.GetDirectoryName(fullname); string name = Path.GetFileName(fullname); bool fIsDynamic = m.CorModule.IsDynamic; if (fIsDynamic) { sbFlags.Append("[Dynamic] "); } CorDebugJITCompilerFlags flags = m.CorModule.JITCompilerFlags; bool fNotOptimized = (flags & CorDebugJITCompilerFlags. CORDEBUG_JIT_DISABLE_OPTIMIZATION) == CorDebugJITCompilerFlags. CORDEBUG_JIT_DISABLE_OPTIMIZATION; if (fNotOptimized) { sbFlags.Append("[Not-optimized] "); } else { sbFlags.Append("[Optimized] "); } // Columns: Id, Name, Path, Flags temp[idx++] = new ListViewItem( new[] { m.Number.ToString(), name, directory , sbFlags.ToString() } ); } }); // end worker if (temp != null) { foreach (ListViewItem x in temp) { items.Add(x); } } }
internal void InitializeCachedValues() { // Cache the value so it's possible to read it even when the process is running jitFlags = module.JITCompilerFlags; }
void SetJITCompilerFlags() { if (Process.DebugMode != DebugModeFlag.Default) { // translate DebugModeFlags to JITCompilerFlags CorDebugJITCompilerFlags jcf = MapDebugModeToJITCompilerFlags(Process.DebugMode); try { this.JITCompilerFlags = jcf; // Flags may succeed but not set all bits, so requery. CorDebugJITCompilerFlags jcfActual = this.JITCompilerFlags; #if DEBUG if (jcf != jcfActual) Console.WriteLine("Couldn't set all flags. Actual flags:" + jcfActual.ToString()); else Console.WriteLine("Actual flags:" + jcfActual.ToString()); #endif } catch (COMException ex) { // we'll ignore the error if we cannot set the jit flags Console.WriteLine(string.Format("Failed to set flags with hr=0x{0:x}", ex.ErrorCode)); } } }
internal VirtualSourceViewerForm(MainForm parent, MDbgFunction function) { m_function = function; Debug.Assert(function != null); // Now actually right in text. do this first so that we can get the current font. BeginInit(parent); // Get fonts FontCache cache; { Font fontCurrent = richText.Font; var emphasis = new Font( fontCurrent.FontFamily, fontCurrent.Size, FontStyle.Bold ); cache = new FontCache(emphasis); } // Underlying writer to the window. var rawWriter = new RawWriter(cache); // Il2Native mapping can be used to find out what IL offsets we can actually stop on. Il2NativeIterator il2nativeIterator = null; // Actual IL disassembly in string form. ILDasmIterator ilDasm = null; // Iterator through sequence points and source files. SequencePointIterator seqIterator = null; string fullName = "?"; int token = 0; ulong nativeStartAddress = 0; CorDebugJITCompilerFlags codeFlags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT; // Make cross-thread call to worker thread to collect raw information. // This needs to access MDbg and so can't be done on our UI thread. parent.ExecuteOnWorkerThreadIfStoppedAndBlock(delegate(MDbgProcess proc) { Debug.Assert(proc != null); Debug.Assert(!proc.IsRunning); Debug.Assert(function.Module.Process == proc); // Get some properties about this function to display. token = function.CorFunction.Token; nativeStartAddress = function.CorFunction.NativeCode.Address; codeFlags = function.CorFunction.NativeCode.CompilerFlags; CorCode ilCode = function.CorFunction.ILCode; Debug.Assert(ilCode.IsIL); byte[] code = ilCode.GetCode(); fullName = function.FullName; // This does the real disassembly work. string[] lines = null; // strings of IL. ILDisassembler.Disassemble(code, function.Module.Importer, out lines, out m_il2RowMapping); ilDasm = new ILDasmIterator(rawWriter, m_il2RowMapping, lines); IL2NativeMap[] il2nativeMapping = function.CorFunction.NativeCode. GetILToNativeMapping(); il2nativeIterator = new Il2NativeIterator(rawWriter, il2nativeMapping, code); // Get sequence points ISymbolMethod symMethod = function.SymMethod; // Sequence point information int[] seqIlOffsets = null; string[] seqPaths = null; int[] seqStartLines = null, seqEndLines = null, seqStartColumns = null, seqEndColumns = null; int seqCount = 0; if (symMethod != null) { seqCount = symMethod.SequencePointCount; seqIlOffsets = new int[seqCount]; var seqDocuments = new ISymbolDocument[seqCount]; seqPaths = new string[seqCount]; seqStartLines = new int[seqCount]; seqEndLines = new int[seqCount]; seqStartColumns = new int[seqCount]; seqEndColumns = new int[seqCount]; symMethod.GetSequencePoints(seqIlOffsets, seqDocuments, seqStartLines, seqStartColumns, seqEndLines, seqEndColumns); for (int i = 0; i < seqCount; i++) { seqPaths[i] = seqDocuments[i].URL; } } seqIterator = new SequencePointIterator(rawWriter, parent, seqIlOffsets, seqPaths, seqStartLines, seqStartColumns, seqEndLines, seqEndColumns); } ); // end worker call // We assume sequence points are sorted by IL offset. We assert that in the iterators below. // Now we need to go through and stitch the IL + Source together. // This also works even if we have no source (since that's just the degenerate case of 0 sequence points) // Print out header information Debug.Assert(token != 0); rawWriter.WriteLine(String.Format(CultureInfo.InvariantCulture, "> Function name:{0} (token={1:x})", fullName, token)); rawWriter.WriteLine(String.Format(CultureInfo.InvariantCulture, "> Native Code Address =0x{0:x}, flags={1}", nativeStartAddress, codeFlags)); // Walk through the IL in order and write out interleaved IL and Sequence Points. while (!seqIterator.IsDone) { // Add IL snippets that occur before this sequence point. WriteIlAndNative(ilDasm, il2nativeIterator, seqIterator.IlOffset); seqIterator.WriteSource(); seqIterator.Next(); } // Write the IL that's after the last sequence point WriteIlAndNative(ilDasm, il2nativeIterator, ilDasm.IlLength); // Set the text. InitLines(null, rawWriter.Lines, rawWriter.FormatList); EndInit(fullName); }
void SetJITCompilerFlags() { // ad CORDEBUG_JIT_ENABLE_ENC: // see issue #553 on GitHub: "ExecutionEngineException or AccessViolationException (CLR 2.0) // when debugging a program that uses System.Data.OleDb" // System.Data.dll (partially) is a C++/CLI assembly and EnC is not supported there. // trying to set CORDEBUG_JIT_ENABLE_ENC succeeds at first, but leads to strange exceptions afterwards. // CORDEBUG_JIT_ENABLE_ENC should only be set for managed-only modules with User Code. CorDebugJITCompilerFlags flags; if (this.Process.Options.SuppressJITOptimization) { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DISABLE_OPTIMIZATION; } else { flags = CorDebugJITCompilerFlags.CORDEBUG_JIT_DEFAULT; } try { this.JITCompilerFlags = flags; } catch (COMException ex) { Console.WriteLine(string.Format("Failed to set flags with hr=0x{0:x}", ex.ErrorCode)); } CorDebugJITCompilerFlags actual = this.JITCompilerFlags; if (flags != actual) this.Process.TraceMessage("Couldn't set JIT flags to {0}. Actual flags: {1}", flags, actual); else this.Process.TraceMessage("JIT flags: {0}", actual); }