allow dec/hex strings. If string doesn't parse as a int, treat as string

Author: Max Charlamb

src/coreclr/tools/cdac-build-tool/JsonConverter/GlobalValueJsonConverter.cs

@@ -18,8 +18,9 @@ public override void Write(Utf8JsonWriter writer, DataDescriptorModel.GlobalValu
         switch (value.Kind)
         {
             case DataDescriptorModel.GlobalValue.KindEnum.Direct:
-                // no type: just write value as a JSON number.
-                writer.WriteNumberValue(value.NumericValue);
+                // no type: just write value as a number.
+                // we always write as a string containing a hex number
+                writer.WriteStringValue($"0x{value.NumericValue:x}");
                 break;
             case DataDescriptorModel.GlobalValue.KindEnum.Indirect:
                 // pointer data index.  write as a 1-element array containing a decimal number

src/native/managed/cdacreader/Microsoft.Diagnostics.DataContractReader/ContractDescriptorParser.cs

@@ -171,14 +171,14 @@ internal sealed class FieldDescriptorConverter : JsonConverter<FieldDescriptor>
         // 2. [number, string] - offset is given as the number, type name is given as the string
         public override FieldDescriptor Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
         {
-            if (TryGetInt32FromTokenFlexible(ref reader, out int offset))
+            if (TryGetInt32FromToken(ref reader, out int offset))
                 return new FieldDescriptor { Offset = offset };
             if (reader.TokenType != JsonTokenType.StartArray)
                 throw new JsonException();
             reader.Read();
             //   [number, string]
             //    ^ we're here
-            if (!TryGetInt32FromTokenFlexible(ref reader, out offset))
+            if (!TryGetInt32FromToken(ref reader, out offset))
                 throw new JsonException();
             reader.Read(); // string
             if (reader.TokenType != JsonTokenType.String)
@@ -303,7 +303,7 @@ private static bool TryGetStringFromToken(ref Utf8JsonReader reader, out string
         return false;
     }
 
-    // Somewhat flexible parsing of numbers, allowing signed or unsigned json number tokens.
+    // Somewhat flexible parsing of numbers, allowing json number tokens or strings as decimal or hex, possibly negated.
     private static bool TryGetUInt64FromToken(ref Utf8JsonReader reader, out ulong value)
     {
         if (reader.TokenType == JsonTokenType.Number)
@@ -316,12 +316,39 @@ private static bool TryGetUInt64FromToken(ref Utf8JsonReader reader, out ulong v
                 return true;
             }
         }
+        if (reader.TokenType == JsonTokenType.String)
+        {
+            var s = reader.GetString();
+            if (s == null)
+            {
+                value = 0u;
+                return false;
+            }
+            if (ulong.TryParse(s, out value))
+                return true;
+            if (long.TryParse(s, out long signedValue))
+            {
+                value = (ulong)signedValue;
+                return true;
+            }
+            if (s.StartsWith("0x", StringComparison.OrdinalIgnoreCase) &&
+                ulong.TryParse(s.AsSpan(2), System.Globalization.NumberStyles.HexNumber, null, out value))
+            {
+                return true;
+            }
+            if (s.StartsWith("-0x", StringComparison.OrdinalIgnoreCase) &&
+                ulong.TryParse(s.AsSpan(3), System.Globalization.NumberStyles.HexNumber, null, out ulong negValue))
+            {
+                value = ~negValue + 1; // two's complement
+                return true;
+            }
+        }
         value = 0;
         return false;
     }
 
-    // Somewhat flexible parsing of numbers, allowing json number tokens or strings as decimal or hex, possibly negatated.
-    private static bool TryGetInt32FromTokenFlexible(ref Utf8JsonReader reader, out int value)
+    // Somewhat flexible parsing of numbers, allowing json number tokens or strings as decimal or hex, possibly negated.
+    private static bool TryGetInt32FromToken(ref Utf8JsonReader reader, out int value)
     {
         if (reader.TokenType == JsonTokenType.Number)
         {

src/native/managed/cdacreader/tests/ContractDescriptor/ParserTests.cs

@@ -128,12 +128,20 @@ public void ParsesGlobals()
                 "globalPtr": [2],
                 "globalTypedInt": [3, "uint8"],
                 "globalTypedPtr": [[4], "uintptr"],
+                "globalHex": "0x1234",
                 "globalNegative": -2,
                 "globalTypedNegative": [-5, "int32"],
                 "globalString": "Hello",
                 "globalTypedString": ["World", "string"],
                 "globalIntLarge": 18446744073709551615,
-                "globalIntLargeNegative": -9223372036854775808
+                "globalIntLargeNegative": -9223372036854775808,
+                "globalStringyInt": "17",
+                "globalStringyNegative": "-2",
+                "globalNegativeHex": "-0xff",
+                "globalBigStringyInt": "0x123456789abcdef",
+                "globalStringyPtr": ["0x1234"],
+                "globalTypedStringyInt": ["0x1234", "int"],
+                "globalTypedStringyPtr": [["0x1234"], "int"]
             }
         }
         """u8;
@@ -143,7 +151,7 @@ public void ParsesGlobals()
         Assert.Empty(descriptor.Contracts);
         Assert.Empty(descriptor.Types);
 
-        Assert.Equal(10, descriptor.Globals.Count);
+        Assert.Equal(18, descriptor.Globals.Count);
 
         Assert.Equal((ulong)1, descriptor.Globals["globalInt"].NumericValue);
         AssertDirect(descriptor.Globals["globalInt"]);
@@ -159,6 +167,9 @@ public void ParsesGlobals()
         AssertIndirect(descriptor.Globals["globalTypedPtr"]);
         Assert.Equal("uintptr", descriptor.Globals["globalTypedPtr"].Type);
 
+        Assert.Equal((ulong)0x1234, descriptor.Globals["globalHex"].NumericValue);
+        AssertDirect(descriptor.Globals["globalHex"]);
+
         Assert.Equal(unchecked((ulong)-2), descriptor.Globals["globalNegative"].NumericValue);
         AssertDirect(descriptor.Globals["globalNegative"]);
 
@@ -179,6 +190,29 @@ public void ParsesGlobals()
         Assert.Equal(unchecked((ulong)long.MinValue), descriptor.Globals["globalIntLargeNegative"].NumericValue);
         AssertDirect(descriptor.Globals["globalIntLargeNegative"]);
 
+        Assert.Equal((ulong)17, descriptor.Globals["globalStringyInt"].NumericValue);
+        AssertDirect(descriptor.Globals["globalStringyInt"]);
+
+        Assert.Equal(unchecked((ulong)-2), descriptor.Globals["globalStringyNegative"].NumericValue);
+        AssertDirect(descriptor.Globals["globalStringyNegative"]);
+
+        Assert.Equal(unchecked((ulong)-0xff), descriptor.Globals["globalNegativeHex"].NumericValue);
+        AssertDirect(descriptor.Globals["globalNegativeHex"]);
+
+        Assert.Equal((ulong)0x123456789abcdef, descriptor.Globals["globalBigStringyInt"].NumericValue);
+        AssertDirect(descriptor.Globals["globalBigStringyInt"]);
+
+        Assert.Equal((ulong)0x1234, descriptor.Globals["globalStringyPtr"].NumericValue);
+        AssertIndirect(descriptor.Globals["globalStringyPtr"]);
+
+        Assert.Equal((ulong)0x1234, descriptor.Globals["globalTypedStringyInt"].NumericValue);
+        AssertDirect(descriptor.Globals["globalTypedStringyInt"]);
+        Assert.Equal("int", descriptor.Globals["globalTypedStringyInt"].Type);
+
+        Assert.Equal((ulong)0x1234, descriptor.Globals["globalTypedStringyPtr"].NumericValue);
+        AssertIndirect(descriptor.Globals["globalTypedStringyPtr"]);
+        Assert.Equal("int", descriptor.Globals["globalTypedStringyPtr"].Type);
+
         void AssertIndirect(ContractDescriptorParser.GlobalDescriptor descriptor)
             => Assert.Equal(ContractDescriptorParser.GlobalDescriptor.KindEnum.Indirect, descriptor.Kind);