netcore/System.Private.CoreLib/shared/System/IntPtr.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Globalization;
   6 using System.Runtime.CompilerServices;
   7 using System.Runtime.Serialization;
   8 using System.Runtime.Versioning;
   9
  10 #pragma warning disable SA1121 // explicitly using type aliases instead of built-in types
  11 #if BIT64
  12 using nint = System.Int64;
  13 #else
  14 using nint = System.Int32;
  15 #endif
  16
  17 namespace System
  18 {
  19     [Serializable]
  20     [System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
  21     public readonly struct IntPtr : IEquatable<IntPtr>, ISerializable
  22     {
  23         // WARNING: We allow diagnostic tools to directly inspect this member (_value).
  24         // See https://github.com/dotnet/corert/blob/master/Documentation/design-docs/diagnostics/diagnostics-tools-contract.md for more details.
  25         // Please do not change the type, the name, or the semantic usage of this member without understanding the implication for tools.
  26         // Get in touch with the diagnostics team if you have questions.
  27         private readonly unsafe void* _value; // Do not rename (binary serialization)
  28
  29         [Intrinsic]
  30         public static readonly IntPtr Zero;
  31
  32         [Intrinsic]
  33         [NonVersionable]
  34         public unsafe IntPtr(int value)
  35         {
  36             _value = (void*)value;
  37         }
  38
  39         [Intrinsic]
  40         [NonVersionable]
  41         public unsafe IntPtr(long value)
  42         {
  43 #if BIT64
  44             _value = (void*)value;
  45 #else
  46             _value = (void*)checked((int)value);
  47 #endif
  48         }
  49
  50         [CLSCompliant(false)]
  51         [Intrinsic]
  52         [NonVersionable]
  53         public unsafe IntPtr(void* value)
  54         {
  55             _value = value;
  56         }
  57
  58         private unsafe IntPtr(SerializationInfo info, StreamingContext context)
  59         {
  60             long l = info.GetInt64("value");
  61
  62             if (Size == 4 && (l > int.MaxValue || l < int.MinValue))
  63                 throw new ArgumentException(SR.Serialization_InvalidPtrValue);
  64
  65             _value = (void*)l;
  66         }
  67
  68         unsafe void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
  69         {
  70             if (info == null)
  71                 throw new ArgumentNullException(nameof(info));
  72
  73             info.AddValue("value", ToInt64());
  74         }
  75
  76         public override unsafe bool Equals(object? obj)
  77         {
  78             if (obj is IntPtr)
  79             {
  80                 return (_value == ((IntPtr)obj)._value);
  81             }
  82             return false;
  83         }
  84
  85         unsafe bool IEquatable<IntPtr>.Equals(IntPtr other)
  86         {
  87             return _value == other._value;
  88         }
  89
  90         public override unsafe int GetHashCode()
  91         {
  92 #if BIT64
  93             long l = (long)_value;
  94             return (unchecked((int)l) ^ (int)(l >> 32));
  95 #else
  96             return unchecked((int)_value);
  97 #endif
  98         }
  99
 100         [Intrinsic]
 101         [NonVersionable]
 102         public unsafe int ToInt32()
 103         {
 104 #if BIT64
 105             long l = (long)_value;
 106             return checked((int)l);
 107 #else
 108             return (int)_value;
 109 #endif
 110         }
 111
 112         [Intrinsic]
 113         [NonVersionable]
 114         public unsafe long ToInt64()
 115         {
 116             return (nint)_value;
 117         }
 118
 119         [Intrinsic]
 120         [NonVersionable]
 121         public static unsafe explicit operator IntPtr(int value)
 122         {
 123             return new IntPtr(value);
 124         }
 125
 126         [Intrinsic]
 127         [NonVersionable]
 128         public static unsafe explicit operator IntPtr(long value)
 129         {
 130             return new IntPtr(value);
 131         }
 132
 133         [CLSCompliant(false)]
 134         [Intrinsic]
 135         [NonVersionable]
 136         public static unsafe explicit operator IntPtr(void* value)
 137         {
 138             return new IntPtr(value);
 139         }
 140
 141         [CLSCompliant(false)]
 142         [Intrinsic]
 143         [NonVersionable]
 144         public static unsafe explicit operator void* (IntPtr value)
 145         {
 146             return value._value;
 147         }
 148
 149         [Intrinsic]
 150         [NonVersionable]
 151         public static unsafe explicit operator int(IntPtr value)
 152         {
 153 #if BIT64
 154             long l = (long)value._value;
 155             return checked((int)l);
 156 #else
 157             return (int)value._value;
 158 #endif
 159         }
 160
 161         [Intrinsic]
 162         [NonVersionable]
 163         public static unsafe explicit operator long(IntPtr value)
 164         {
 165             return (nint)value._value;
 166         }
 167
 168         [Intrinsic]
 169         [NonVersionable]
 170         public static unsafe bool operator ==(IntPtr value1, IntPtr value2)
 171         {
 172             return value1._value == value2._value;
 173         }
 174
 175         [Intrinsic]
 176         [NonVersionable]
 177         public static unsafe bool operator !=(IntPtr value1, IntPtr value2)
 178         {
 179             return value1._value != value2._value;
 180         }
 181
 182         [NonVersionable]
 183         public static IntPtr Add(IntPtr pointer, int offset)
 184         {
 185             return pointer + offset;
 186         }
 187
 188         [Intrinsic]
 189         [NonVersionable]
 190         public static unsafe IntPtr operator +(IntPtr pointer, int offset)
 191         {
 192             return new IntPtr((nint)pointer._value + offset);
 193         }
 194
 195         [NonVersionable]
 196         public static IntPtr Subtract(IntPtr pointer, int offset)
 197         {
 198             return pointer - offset;
 199         }
 200
 201         [Intrinsic]
 202         [NonVersionable]
 203         public static unsafe IntPtr operator -(IntPtr pointer, int offset)
 204         {
 205             return new IntPtr((nint)pointer._value - offset);
 206         }
 207
 208         public static int Size
 209         {
 210             [Intrinsic]
 211             [NonVersionable]
 212             get
 213             {
 214                 return sizeof(nint);
 215             }
 216         }
 217
 218         [CLSCompliant(false)]
 219         [Intrinsic]
 220         [NonVersionable]
 221         public unsafe void* ToPointer()
 222         {
 223             return _value;
 224         }
 225
 226         public override unsafe string ToString()
 227         {
 228             return ((nint)_value).ToString(CultureInfo.InvariantCulture);
 229         }
 230
 231         public unsafe string ToString(string format)
 232         {
 233             return ((nint)_value).ToString(format, CultureInfo.InvariantCulture);
 234         }
 235     }
 236 }