Failed() публичный статический Метод

public static Failed ( int hr ) : bool
hr int
Результат bool
Пример #1
0
            private void FillLocation(ArgumentOrLocal argOrLocal, IXCLRDataValue value)
            {
                uint numLocs;

                if (HR.Failed(value.GetNumLocations(out numLocs)))
                {
                    return;
                }

                // Values could span multiple locations when they are enregistered.
                // The IXCLRDataValue::GetBytes method is supposed to take care of it,
                // but we don't have a location to display. We don't even get the
                // register name(s), so there's really nothing to display in this case.
                if (numLocs != 1)
                {
                    return;
                }

                uint  flags;
                ulong address;

                if (HR.Failed(value.GetLocationByIndex(0, out flags, out address)))
                {
                    return;
                }

                // Only memory locations have a memory address.
                if (flags == (uint)ClrDataValueLocationFlag.CLRDATA_VLOC_MEMORY)
                {
                    argOrLocal.Location = address;
                }
            }
Пример #2
0
        public static void ExecuteDbgEngCommand(this DataTarget target, string command, CommandExecutionContext context)
        {
            IDebugControl6 control = (IDebugControl6)target.DebuggerInterface;
            int            hr      = control.ExecuteWide(
                DEBUG_OUTCTL.THIS_CLIENT, command, DEBUG_EXECUTE.DEFAULT);

            if (HR.Failed(hr))
            {
                context.WriteErrorLine("Command execution failed with hr = {0:x8}", hr);
            }
        }
Пример #3
0
            private string GetModuleName(IXCLRDataModule module)
            {
                StringBuilder name = new StringBuilder(MaxNameSize);
                uint          nameLen;

                if (HR.Failed(module.GetName((uint)name.Capacity, out nameLen, name)))
                {
                    return(null);
                }

                return(name.ToString());
            }
Пример #4
0
            private bool FailedUnlessOnCLR2DAC(int hr)
            {
                // For CLR v2 DAC, if the return HRESULT is random garbage, ignore the error.
                // This happens because of a source-level bug in the DAC that returns an
                // uninitialized stack variable. This was confirmed by a Microsoft engineer.
                if (_isOnCLRv2)
                {
                    return(false);
                }

                return(HR.Failed(hr));
            }
Пример #5
0
            public void Fill(IDebugAdvanced2 debugAdvanced)
            {
                int size = Marshal.SizeOf(typeof(DEBUG_THREAD_BASIC_INFORMATION));

                byte[] buffer = new byte[size];
                if (HR.Failed(debugAdvanced.GetSystemObjectInformation(
                                  DEBUG_SYSOBJINFO.THREAD_BASIC_INFORMATION, 0, EngineThreadId, buffer, buffer.Length, out size)))
                {
                    return;
                }

                var gch = GCHandle.Alloc(buffer, GCHandleType.Pinned);

                try
                {
                    var threadBasicInformation = (DEBUG_THREAD_BASIC_INFORMATION)
                                                 Marshal.PtrToStructure(gch.AddrOfPinnedObject(), typeof(DEBUG_THREAD_BASIC_INFORMATION));
                    if ((threadBasicInformation.Valid & DEBUG_TBINFO.AFFINITY) != 0)
                    {
                        Affinity = threadBasicInformation.Affinity;
                    }
                    if ((threadBasicInformation.Valid & DEBUG_TBINFO.PRIORITY_CLASS) != 0)
                    {
                        PriorityClass = threadBasicInformation.PriorityClass;
                    }
                    if ((threadBasicInformation.Valid & DEBUG_TBINFO.PRIORITY) != 0)
                    {
                        Priority = threadBasicInformation.Priority;
                    }
                    if ((threadBasicInformation.Valid & DEBUG_TBINFO.TIMES) != 0)
                    {
                        CreateTime = threadBasicInformation.CreateTime;
                        KernelTime = threadBasicInformation.KernelTime;
                        UserTime   = threadBasicInformation.UserTime;
                    }
                }
                finally
                {
                    gch.Free();
                }
            }
Пример #6
0
            private void FillValue(ArgumentOrLocal argOrLocal, IXCLRDataValue value)
            {
                object tmp;

                ulong size;

                if (HR.Failed(value.GetSize(out size)))
                {
                    size = 0; // When the value is unavailable, GetSize fails; consider it 0
                }
                argOrLocal.Size = size;

                bool probablyReferenceType = false;
                int  getTypeHr             = value.GetType(out tmp);

                if (getTypeHr == HR.S_FALSE)
                {
                    // For reference types, GetType returns S_FALSE and we need to call GetAssociatedType
                    // to retrieve the type that the reference points to.
                    getTypeHr             = value.GetAssociatedType(out tmp);
                    probablyReferenceType = (getTypeHr == HR.S_OK);
                }

                if (getTypeHr != HR.S_OK)
                {
                    return;
                }

                IXCLRDataTypeInstance typeInstance = (IXCLRDataTypeInstance)tmp;
                StringBuilder         typeName     = new StringBuilder(MaxNameSize);
                uint typeNameLen;

                if (FailedUnlessOnCLR2DAC(typeInstance.GetName(0 /*CLRDATA_GETNAME_DEFAULT*/, (uint)typeName.Capacity, out typeNameLen, typeName)))
                {
                    return;
                }

                argOrLocal.StaticTypeName = typeName.ToString();
                argOrLocal.ClrType        = _context.Heap.GetTypeByName(argOrLocal.StaticTypeName);

                // If the value is unavailable, we're done here.
                if (size == 0)
                {
                    return;
                }

                FillLocation(argOrLocal, value);

                argOrLocal.Value = new byte[size];
                uint dataSize;

                if (HR.Failed(value.GetBytes((uint)argOrLocal.Value.Length, out dataSize, argOrLocal.Value)))
                {
                    argOrLocal.Value = null;
                }

                // If the type is an array type (e.g. System.Byte[]), or a pointer type
                // (e.g. System.Byte*), or a by-ref type (e.g. System.Byte&), ClrHeap.GetTypeByName
                // will never return a good value. This is only a problem with variables that
                // are either ref types and null (and then we can't get the type name from
                // the object itself), variables that are pointers, and variables that are
                // by-ref types. Here's the plan:
                //  1) If the variable is a ref type and is null, we don't care about the
                //     ClrType being correct anyway. We report the type returned by GetName
                //     above, and report the value as null.
                //  2) If the value is a by-ref type or a pointer type, IXCLRDataValue::GetFlags
                //     can detect it. Then, we keep the ClrType null (because ClrMD doesn't have
                //     a representation for pointer types or by-ref types), but we read the
                //     value anyway by dereferencing the pointer. According to the comments in
                //     xclrdata.idl, IXCLRDataValue::GetAssociatedValue is supposed to return the
                //     pointed-to value, but it doesn't (it only works for references).

                uint             vf;
                CLRDataValueFlag valueFlags = CLRDataValueFlag.Invalid;

                if (HR.S_OK == value.GetFlags(out vf))
                {
                    valueFlags = (CLRDataValueFlag)vf;
                }

                // * Pointers are identified as CLRDATA_VALUE_IS_POINTER.
                // * By-refs are identified as CLRDATA_VALUE_DEFAULT regardless of referenced type.
                bool byRefOrPointerType =
                    (valueFlags & CLRDataValueFlag.CLRDATA_VALUE_IS_POINTER) != 0 ||
                    (valueFlags == CLRDataValueFlag.CLRDATA_VALUE_DEFAULT /* it is 0 */);

                if (byRefOrPointerType)
                {
                    // By-refs to pointers are identified as CLRDATA_VALUE_DEFAULT with target UInt64,
                    // which makes them undistinguishable from 'ref ulong', unfortunately. But if the
                    // type name reported didn't include the &, we know that's what it is.
                    if (argOrLocal.StaticTypeName == "System.UInt64")
                    {
                        argOrLocal.ClrType        = null; // We don't really know what the type is
                        argOrLocal.StaticTypeName = "UNKNOWN*&";
                    }

                    if (argOrLocal.Value != null)
                    {
                        ulong ptrValue = RawBytesToAddress(argOrLocal.Value);

                        ulong potentialReference;
                        if (_context.Runtime.ReadPointer(ptrValue, out potentialReference) &&
                            (argOrLocal.ClrType = _context.Heap.GetObjectType(potentialReference)) != null)
                        {
                            // If the type was resolved, then this was the address of a heap object.
                            // In that case, we're done and we have a type.
                            argOrLocal.ObjectAddress = potentialReference;
                        }
                        else
                        {
                            // Otherwise, this address is the address of a value type. We don't know
                            // which type, because IXCLRDataValue::GetAssociatedType doesn't return anything
                            // useful when the value is a pointer or by-ref. But we can try to remove
                            // the * or & from the type name, and then try to figure out what the target
                            // type is.
                            string noRefNoPtrTypeName = argOrLocal.StaticTypeName.TrimEnd('&', '*');
                            if ((argOrLocal.ClrType = _context.Heap.GetTypeByName(noRefNoPtrTypeName))
                                != null)
                            {
                                argOrLocal.Location = ptrValue;
                            }
                        }
                    }
                }

                if (argOrLocal.ClrType == null)
                {
                    // If the type is an inner type, IXCLRDataTypeInstance::GetName reports only
                    // the inner part of the type. This isn't enough for ClrHeap.GetTypeByName,
                    // so we have yet another option in that case -- searching by metadata token.
                    TryGetTypeByMetadataToken(argOrLocal, typeInstance);

                    // If we had a pointer or by-ref type and didn't know what it was, we now do,
                    // so we can store its location and have it displayed.
                    if (byRefOrPointerType && argOrLocal.ClrType != null)
                    {
                        argOrLocal.Location = RawBytesToAddress(argOrLocal.Value);
                    }
                }

                if (!byRefOrPointerType && (probablyReferenceType || argOrLocal.IsReferenceType))
                {
                    argOrLocal.ObjectAddress = RawBytesToAddress(argOrLocal.Value);
                    // The type assigned here can be different from the previous value,
                    // because the static and dynamic type of the argument could differ.
                    // If the object reference is null or invalid, it could also be null --
                    // so we keep the previous type if it was already available.
                    argOrLocal.ClrType =
                        _context.Heap.GetObjectType(argOrLocal.ObjectAddress) ?? argOrLocal.ClrType;
                }
            }
Пример #7
0
            private void ProcessFrame(IXCLRDataStackWalk stackWalk)
            {
                object tmp;

                if (HR.Failed(stackWalk.GetFrame(out tmp)))
                {
                    return;
                }

                IXCLRDataFrame frame = (IXCLRDataFrame)tmp;

                StringBuilder methodName = new StringBuilder(MaxNameSize);
                uint          methodNameLen;

                if (HR.Failed(frame.GetCodeName(0 /*default flags*/, (uint)methodName.Capacity, out methodNameLen, methodName)))
                {
                    return;
                }

                uint numArgs, numLocals;

                if (HR.Failed(frame.GetNumArguments(out numArgs)))
                {
                    numArgs = 0;
                }
                if (HR.Failed(frame.GetNumLocalVariables(out numLocals)))
                {
                    numLocals = 0;
                }

                FrameArgumentsAndLocals frameArgsLocals = new FrameArgumentsAndLocals()
                {
                    MethodName = methodName.ToString()
                };

                for (uint argIdx = 0; argIdx < numArgs; ++argIdx)
                {
                    StringBuilder argName = new StringBuilder(MaxNameSize);
                    uint          argNameLen;

                    if (FailedUnlessOnCLR2DAC(frame.GetArgumentByIndex(argIdx, out tmp, (uint)argName.Capacity, out argNameLen, argName)) ||
                        tmp == null)
                    {
                        continue;
                    }

                    var arg = new ArgumentOrLocal()
                    {
                        Name = argName.ToString()
                    };
                    FillValue(arg, (IXCLRDataValue)tmp);
                    frameArgsLocals.Arguments.Add(arg);
                }

                for (uint lclIdx = 0; lclIdx < numLocals; ++lclIdx)
                {
                    // The mscordacwks!ClrDataFrame::GetLocalVariableByIndex implementation never returns
                    // names for local variables. Need to go through metadata to get them.
                    StringBuilder dummy = new StringBuilder(2);
                    uint          lclNameLen;
                    if (FailedUnlessOnCLR2DAC(frame.GetLocalVariableByIndex(lclIdx, out tmp, (uint)dummy.Capacity, out lclNameLen, dummy)) ||
                        tmp == null)
                    {
                        continue;
                    }

                    string lclName       = dummy.ToString();
                    var    matchingFrame = _stackTrace.SingleOrDefault(f => f.DisplayString == frameArgsLocals.MethodName);
                    if (matchingFrame != null)
                    {
                        lclName = GetLocalVariableName(matchingFrame.InstructionPointer, lclIdx);
                    }

                    var lcl = new ArgumentOrLocal()
                    {
                        Name = lclName
                    };
                    FillValue(lcl, (IXCLRDataValue)tmp);
                    frameArgsLocals.LocalVariables.Add(lcl);
                }

                _results.Add(frameArgsLocals);
            }
Пример #8
0
        public static LastEventInformation GetLastEventInformation(this DataTarget target)
        {
            var           control = (IDebugControl)target.DebuggerInterface;
            DEBUG_EVENT   eventType;
            uint          procId, threadId;
            StringBuilder description = new StringBuilder(2048);
            uint          unused;
            uint          descriptionSize;

            if (HR.Failed(control.GetLastEventInformation(
                              out eventType, out procId, out threadId,
                              IntPtr.Zero, 0, out unused,
                              description, description.Capacity, out descriptionSize)))
            {
                return(null);
            }

            var osThreadIds      = target.GetOSThreadIds();
            var eventInformation = new LastEventInformation
            {
                OSThreadId       = (int)osThreadIds[threadId],
                EventType        = eventType,
                EventDescription = description.ToString()
            };

            IDebugAdvanced2 debugAdvanced = (IDebugAdvanced2)target.DebuggerInterface;
            int             outSize;

            byte[] buffer = new byte[Marshal.SizeOf(typeof(EXCEPTION_RECORD64))];
            int    hr     = debugAdvanced.Request(DEBUG_REQUEST.TARGET_EXCEPTION_RECORD, null, 0, buffer, buffer.Length, out outSize);

            if (HR.Succeeded(hr))
            {
                GCHandle gch = GCHandle.Alloc(buffer, GCHandleType.Pinned);
                try
                {
                    eventInformation.ExceptionRecord = (EXCEPTION_RECORD64)Marshal.PtrToStructure(gch.AddrOfPinnedObject(), typeof(EXCEPTION_RECORD64));
                }
                finally
                {
                    gch.Free();
                }
            }

            buffer = new byte[Marshal.SizeOf(typeof(uint))];
            hr     = debugAdvanced.Request(DEBUG_REQUEST.TARGET_EXCEPTION_THREAD, null, 0, buffer, buffer.Length, out outSize);
            if (HR.Succeeded(hr))
            {
                // If there is a stored exception event with a thread id, use that instead
                // of what GetLastEventInformation returns, because it might be different.
                eventInformation.OSThreadId = (int)BitConverter.ToUInt32(buffer, 0);
            }

            buffer = new byte[Marshal.SizeOf(typeof(CONTEXT))];
            hr     = debugAdvanced.Request(DEBUG_REQUEST.TARGET_EXCEPTION_CONTEXT, null, 0, buffer, buffer.Length, out outSize);
            if (HR.Succeeded(hr))
            {
                var gch = GCHandle.Alloc(buffer, GCHandleType.Pinned);
                try
                {
                    eventInformation.ExceptionContext = (CONTEXT)Marshal.PtrToStructure(
                        gch.AddrOfPinnedObject(), typeof(CONTEXT));
                }
                finally
                {
                    gch.Free();
                }
            }

            return(eventInformation);
        }