Mono.Debugger.Backend.DwarfFrameReader.UnwindStack C# (CSharp) Method

        public StackFrame UnwindStack(StackFrame frame, TargetMemoryAccess target,
					       Architecture arch)
        {
            if (frame.TargetAddress.IsNull)
                return null;

            TargetAddress address = frame.TargetAddress;

            DwarfBinaryReader reader = new DwarfBinaryReader (bfd, blob, false);

            while (reader.Position < reader.Size) {
                long length = reader.ReadInitialLength ();
                if (length == 0)
                    break;
                long end_pos = reader.Position + length;

                long cie_pointer = reader.ReadOffset ();
                bool is_cie;
                if (is_ehframe)
                    is_cie = cie_pointer == 0;
                else
                    is_cie = cie_pointer == -1;

                if (is_cie) {
                    reader.Position = end_pos;
                    continue;
                }

                if (is_ehframe)
                    cie_pointer = reader.Position - cie_pointer -
                        target.TargetMemoryInfo.TargetAddressSize;

                CIE cie = find_cie (cie_pointer);

                long initial, range;
                if (is_ehframe) {
                    initial = ReadEncodedValue (reader, cie.Encoding);
                    range = ReadEncodedValue (reader, cie.Encoding & 0x0f);
                } else {
                    initial = reader.ReadAddress ();
                    range = reader.ReadAddress ();
                }

                TargetAddress start = new TargetAddress (target.AddressDomain, initial);

                if ((address < start) || (address > start + range)) {
                    reader.Position = end_pos;
                    continue;
                }

                Entry fde = new Entry (cie, start, address);
                fde.Read (reader, end_pos);
                return fde.Unwind (frame, target, arch);
            }

            return null;
        }

        protected StackFrame UnwindStack(StackFrame frame, TargetMemoryAccess memory)
        {
            if ((frame.TargetAddress < StartAddress) || (frame.TargetAddress > EndAddress))
            {
                return(null);
            }

            StackFrame new_frame;

            try {
                new_frame = Architecture.TrySpecialUnwind(frame, memory);
                if (new_frame != null)
                {
                    return(new_frame);
                }
            } catch {
            }

            try {
                if (frame_reader != null)
                {
                    new_frame = frame_reader.UnwindStack(frame, memory, Architecture);
                    if (new_frame != null)
                    {
                        return(new_frame);
                    }
                }

                if (eh_frame_reader != null)
                {
                    new_frame = eh_frame_reader.UnwindStack(frame, memory, Architecture);
                    if (new_frame != null)
                    {
                        return(new_frame);
                    }
                }
            } catch {
                return(null);
            }

            return(null);
        }