internal override TargetType GetCurrentType(TargetMemoryAccess target)
        {
            if (!Type.HasStaticType)
                throw new InvalidOperationException ();

            return Type.StaticType;
        }

        internal override TargetBlob ReadMemory(TargetMemoryAccess target, int size)
        {
            if (!is_valid)
                throw new LocationInvalidException ();

            if (HasAddress)
                return base.ReadMemory (target, size);

            // If this is a valuetype, the register hold the whole data.
            long contents = address.Address;

            byte[] buffer;
            if (size == 1)
                buffer = BitConverter.GetBytes ((byte) contents);
            else if (size == 2)
                buffer = BitConverter.GetBytes ((short) contents);
            else if (size == 4)
                buffer = BitConverter.GetBytes ((int) contents);
            else if (size == 8)
                buffer = BitConverter.GetBytes (contents);
            else
                throw new ArgumentException ();

            return new TargetBlob (buffer, target.TargetMemoryInfo);
        }

        internal override TargetClassObject GetCurrentObject(TargetMemoryAccess target)
        {
            if (!type.IsByRef)
                return null;

            return type.GetCurrentObject (target, Location);
        }

 internal override string Print(TargetMemoryAccess target)
 {
     if (Location.HasAddress)
         return String.Format ("{0}", Location.GetAddress (target));
     else
         return String.Format ("{0}", Location);
 }

        internal override void SetObject(TargetMemoryAccess target, TargetLocation location,
						  TargetObject obj)
        {
            TargetLocation flag_loc = location.GetLocationAtOffset (ElementType.Size);
            byte[] buffer = new byte [1];

            if (obj is TargetNullObject) {
                buffer [0] = 0;
                flag_loc.WriteBuffer (target, buffer);
                return;
            }

            MonoNullableObject nobj = obj as MonoNullableObject;
            if (nobj != null) {
                if (!nobj.HasValue (target)) {
                    buffer [0] = 0;
                    flag_loc.WriteBuffer (target, buffer);
                    return;
                } else {
                    obj = nobj.GetValue (target);
                }
            }

            buffer [0] = 1;
            flag_loc.WriteBuffer (target, buffer);

            ElementType.SetObject (target, location, obj);
        }

        internal override void WriteBuffer(TargetMemoryAccess target, byte[] data)
        {
            if (data.Length > blob.Size)
                throw new ArgumentException ();

            data.CopyTo (blob.Contents, 0);
        }

 internal override string Print(TargetMemoryAccess target)
 {
     if (Location.GetAddress (target).IsNull)
         return "null";
     object obj = DoGetObject (target);
     return '"' + (string) obj + '"';
 }

 internal override string Print(TargetMemoryAccess target)
 {
     if (HasAddress)
         return String.Format ("{0} ({1})", Type.Name, GetAddress (target));
     else
         return String.Format ("{0} ({1})", Type.Name, Location);
 }

        internal override TargetAddress GetAddress(TargetMemoryAccess target)
        {
            if (!is_valid)
                throw new LocationInvalidException ();

            return address;
        }

 internal override TargetObject GetDereferencedObject(TargetMemoryAccess target)
 {
     if (Type.StaticType is TargetPointerType) {
         TargetLocation loc = GetDereferencedLocation ();
         return Type.StaticType.GetObject (target, loc);
     } else
         return Type.StaticType.GetObject (target, Location);
 }

 protected override object DoGetObject(TargetMemoryAccess target)
 {
     try {
         return ReadString (target, Location);
     } catch (TargetException ex) {
         throw new LocationInvalidException (ex);
     }
 }

        internal override long GetDynamicSize(TargetMemoryAccess target, TargetBlob blob,
						       TargetLocation location,
						       out TargetLocation dynamic_location)
        {
            int element_size = Type.GetElementSize (target);
            dynamic_location = location.GetLocationAtOffset (Type.Size);
            return element_size * GetLength (target);
        }

 internal override TargetAddress GetAddress(TargetMemoryAccess target)
 {
     TargetAddress address = reference.GetAddress (target);
     if (address.IsNull)
         return TargetAddress.Null;
     else
         return target.ReadAddress (address);
 }

        public AppDomainInfo GetAppDomainInfo(MonoLanguageBackend mono, TargetMemoryAccess memory,
						       TargetAddress address)
        {
            int addr_size = memory.TargetMemoryInfo.TargetAddressSize;
            TargetReader reader = new TargetReader (memory.ReadMemory (address, 12 * addr_size));

            return new AppDomainInfo (mono, memory, reader);
        }

 internal override string Print(TargetMemoryAccess target)
 {
     TargetAddress address = GetAddress (target);
     if (address.IsNull)
         return "null";
     else
         return String.Format ("{0}", address);
 }

        internal override long GetDynamicSize(TargetMemoryAccess target, TargetBlob blob,
						       TargetLocation location,
						       out TargetLocation dynamic_location)
        {
            TargetBinaryReader reader = blob.GetReader ();
            reader.Position = Type.ObjectSize;
            dynamic_location = location.GetLocationAtOffset (Type.ObjectSize + 4);
            return reader.ReadInteger (4) * 2;
        }

        public static MonoVariableLocation Create(TargetMemoryAccess target, bool is_regoffset,
							   Register register, long regoffset,
							   bool is_byref)
        {
            MonoVariableLocation location = new MonoVariableLocation (
                is_regoffset, register, regoffset, is_byref);
            location.update (target);
            return location;
        }

 internal override string Print(TargetMemoryAccess target)
 {
     object obj = DoGetObject (target);
     if (obj is IntPtr)
         return String.Format ("0x{0:x}", ((IntPtr) obj).ToInt64 ());
     else if (obj is UIntPtr)
         return String.Format ("0x{0:x}", ((UIntPtr) obj).ToUInt64 ());
     else
         return obj.ToString ();
 }

        internal override TargetBlob ReadMemory(TargetMemoryAccess target, int size)
        {
            if (size > blob.Size)
                throw new ArgumentException ();

            byte[] data = new byte [size];
            Array.Copy (blob.Contents, 0, data, 0, size);

            return new TargetBlob (data, blob.TargetMemoryInfo);
        }

        internal override TargetObject GetElement(TargetMemoryAccess target, int[] indices)
        {
            int offset = GetArrayOffset (target, indices);

            TargetLocation new_location = Location.GetLocationAtOffset (offset);
            if (Type.ElementType.IsByRef)
                new_location = new_location.GetDereferencedLocation ();

            return Type.ElementType.GetObject (target, new_location);
        }