Inheritance: TargetBinaryAccess
        public MethodAddress(TargetBinaryReader reader,
				      AddressDomain domain, Architecture arch)
        {
            // here we read the MonoDebugMethodAddress structure
            // as written out in mono_debug_add_method.
            reader.Position = 16;
            ReadAddress (reader, domain); // wrapper_data
            MonoMethod = ReadAddress (reader, domain);
            ReadAddress (reader, domain); // address_list
            StartAddress = ReadAddress (reader, domain);
            WrapperAddress = ReadAddress (reader, domain);
            int code_size = reader.ReadInt32 ();

            EndAddress = StartAddress + code_size;

            int prologue_end = reader.ReadLeb128 ();
            int epilogue_begin = reader.ReadLeb128 ();

            MethodStartAddress = prologue_end > 0 ?
                StartAddress + prologue_end : StartAddress;
            MethodEndAddress = epilogue_begin > 0 ?
                StartAddress + epilogue_begin : EndAddress;

            int num_line_numbers = reader.ReadLeb128 ();
            LineNumbers = new List<JitLineNumberEntry> ();

            for (int i = 0; i < num_line_numbers; i++) {
                int il_offset = reader.ReadSLeb128 ();
                int native_offset = reader.ReadSLeb128 ();

                if (il_offset < 0)
                    continue;

                LineNumbers.Add (new JitLineNumberEntry (il_offset, native_offset));
            }

            HasThis = reader.ReadByte () != 0;
            if (HasThis)
                ThisVariableInfo = new VariableInfo (arch, reader);

            int num_params = reader.ReadLeb128 ();
            ParamVariableInfo = new VariableInfo [num_params];
            for (int i = 0; i < num_params; i++)
                ParamVariableInfo [i] = new VariableInfo (arch, reader);

            int num_locals = reader.ReadLeb128 ();
            LocalVariableInfo = new VariableInfo [num_locals];
            for (int i = 0; i < num_locals; i++)
                LocalVariableInfo [i] = new VariableInfo (arch, reader);
        }
        protected WrapperMethod GetWrapperMethod(MethodHashEntry hash, WrapperEntry wrapper,
							  byte[] contents)
        {
            WrapperMethod method = (WrapperMethod) wrapper_hash [hash];
            if (method == null) {
                method = new WrapperMethod (this, hash.Domain, wrapper);
                wrapper_hash.Add (hash, method);
            }

            if (!method.IsLoaded) {
                TargetBinaryReader reader = new TargetBinaryReader (contents, TargetMemoryInfo);
                method.Load (reader, TargetMemoryInfo.AddressDomain);
            }

            return method;
        }
        protected MonoMethod GetMonoMethod(MethodHashEntry hash, int index, byte[] contents)
        {
            ensure_sources ();
            if (File == null)
                return null;
            MonoMethod method = (MonoMethod) method_hash [hash];
            if (method == null) {
                MonoMethodSource source = GetMethodSource (index);
                method = new MonoMethod (
                    this, source, hash.Domain, source.Entry, source.Method);
                method_hash.Add (hash, method);
            }

            if (!method.IsLoaded) {
                TargetBinaryReader reader = new TargetBinaryReader (contents, TargetMemoryInfo);
                method.Load (reader, TargetMemoryInfo.AddressDomain);
            }

            return method;
        }
        public VariableInfo(Architecture arch, TargetBinaryReader reader)
        {
            Index = reader.ReadLeb128 ();
            Offset = reader.ReadSLeb128 ();
            Size = reader.ReadLeb128 ();
            BeginLiveness = reader.ReadLeb128 ();
            EndLiveness = reader.ReadLeb128 ();

            MonoType = new TargetAddress (
                reader.TargetMemoryInfo.AddressDomain, reader.ReadAddress ());

            Mode = (AddressMode) (Index & AddressModeFlags);
            Index = (int) ((long) Index & ~AddressModeFlags);

            Report.Debug (DebugFlags.JitSymtab, "VARIABLE INFO: {0} {1} {2} {3} {4}",
                      Mode, Index, Offset, Size, arch);

            if ((Mode == AddressMode.Register) || (Mode == AddressMode.RegOffset))
                Index = arch.RegisterMap [Index];

            Report.Debug (DebugFlags.JitSymtab, "VARIABLE INFO #1: {0}", Index);

            HasLivenessInfo = (BeginLiveness != 0) && (EndLiveness != 0);
        }
            public void Load(TargetBinaryReader dynamic_reader, AddressDomain domain)
            {
                if (is_loaded)
                    throw new InternalError ();

                is_loaded = true;

                address = new MethodAddress (
                    dynamic_reader, domain, File.Architecture);

                SetAddresses (address.StartAddress, address.EndAddress);
                SetMethodBounds (address.MethodStartAddress, address.MethodEndAddress);
                SetLineNumbers (new WrapperLineNumberTable (this, address));
            }
            public void Load(TargetBinaryReader dynamic_reader, AddressDomain domain)
            {
                if (is_loaded)
                    throw new InternalError ();

                is_loaded = true;

                address = new MethodAddress (
                    dynamic_reader, domain, file.Architecture);

                SetAddresses (address.StartAddress, address.EndAddress);
                SetMethodBounds (address.MethodStartAddress, address.MethodEndAddress);

                SetLineNumbers (new MonoMethodLineNumberTable (
                    file, this, source, method, address.LineNumbers.ToArray ()));
            }
 protected TargetAddress ReadAddress(TargetBinaryReader reader, AddressDomain domain)
 {
     long address = reader.ReadAddress ();
     if (address != 0)
         return new TargetAddress (domain, address);
     else
         return TargetAddress.Null;
 }