Add support for Ada 2022's Big_Integer and Big_Real

TN: UA19-042
Change-Id: If877215b73663e73cbb399b49702edb347dce08b

Author: pmderodat

gnatdbg/__init__.py

@@ -2,6 +2,7 @@
 import gdb.printing
 
 
+from gnatdbg.big_numbers import BigIntegerPrinter, BigRealPrinter
 from gnatdbg.lists import (
     DoublyLinkedListPrinter, DoublyLinkedListCursorPrinter,
 )
@@ -31,6 +32,9 @@ def create_printers(name='gnat-runtime'):
     printers = GDBPrettyPrinters(name)
 
     for printer in [
+        BigIntegerPrinter,
+        BigRealPrinter,
+
         DoublyLinkedListPrinter,
         DoublyLinkedListCursorPrinter,
 

gnatdbg/big_numbers.py

@@ -0,0 +1,121 @@
+"""
+Pretty-printers and helpers for big numbers (Ada.Numerics.Big_Numbers).
+"""
+
+import gdb
+
+
+from gnatdbg.printers import PrettyPrinter
+
+
+class BigInteger:
+    """
+    Helper class to inspect Big_Integer values.
+    """
+
+    def __init__(self, value):
+        self.value = value
+
+    @property
+    def _bignum_address(self):
+        return self.value["value"]["c"]
+
+    @property
+    def is_valid(self):
+        """
+        Return whether this big integer is valid.
+        """
+        return bool(self._bignum_address)
+
+    def get(self):
+        # The data structure used to store big numbers is
+        # System.Shared_Bignums.Bignum_Data. Unfortunately, in most cases we
+        # don't have debug info for this type, so we have to poke blindly at
+        # memory.
+        #
+        # We consider that big number data is layed out as an array of uint32_t
+        # values. The first one gives the number N of 32-bit digits that make
+        # up this number (24 least significant bits) and whether that number is
+        # negative (25th bit). Then the next N uint32_t values are the 32-bit
+        # digits for the big number (most significant digits first).
+        #
+        # TODO: it is not clear reading the spec how the first digit is mapped
+        # on big-endian systems.
+        uint32_t = gdb.lookup_type('uint32_t')
+        data_ptr = self._bignum_address.cast(uint32_t.pointer())
+
+        info = data_ptr.dereference()
+        length = info & 0xfff
+        neg = bool(info >> 24)
+
+        array_ptr_type = uint32_t.array(length).pointer()
+        data_array = data_ptr.cast(array_ptr_type).dereference()
+
+        result = 0
+        for i in range(length):
+            result = result << 32 | int(data_array[i + 1])
+
+        if neg:
+            result = -result
+
+        return result
+
+
+class BigReal:
+    """
+    Helper class to inspect Big_Real values.
+    """
+
+    def __init__(self, value):
+        self.value = value
+        self.numerator = BigInteger(value["num"])
+        self.denominator = BigInteger(value["den"])
+
+    @property
+    def is_valid(self):
+        return self.numerator.is_valid and self.denominator.is_valid
+
+    def get_numerator(self):
+        return self.numerator.get()
+
+    def get_denominator(self):
+        return self.denominator.get()
+
+
+class BigIntegerPrinter(PrettyPrinter):
+    """Pretty-print Big_Integer values."""
+
+    name             = 'Big_Integer'
+    type_pretty_name = 'ada.numerics.big_numbers.big_integers.big_integer'
+
+    def to_string(self):
+        val = BigInteger(self.value)
+        value = None
+        try:
+            if val.is_valid:
+                value = val.get()
+        except gdb.MemoryError:
+            value_repr = '[Invalid]'
+        else:
+            value_repr = '[Uninitialized]' if value is None else str(value)
+
+        return f'{self.name} ({value_repr})'
+
+
+class BigRealPrinter(PrettyPrinter):
+    """Pretty-print Big_Real values."""
+
+    name             = 'Big_Real'
+    type_pretty_name = 'ada.numerics.big_numbers.big_reals.big_real'
+
+    def to_string(self):
+        val = BigReal(self.value)
+        try:
+            value_repr = (
+                f'{val.get_numerator()} / {val.get_denominator()}'
+                if val.is_valid
+                else '[Uninitialized]'
+            )
+        except gdb.MemoryError:
+            value_repr = '[Invalid]'
+        return f'{self.name} ({value_repr})'

testsuite/tests/big-integers/foo.adb

@@ -0,0 +1,20 @@
+pragma Ada_2022;
+
+with Ada.Numerics.Big_Numbers.Big_Integers;
+use Ada.Numerics.Big_Numbers.Big_Integers;
+
+procedure Foo is
+   Uninit, Zero                : Big_Integer;
+   Neg_One, Neg_Small, Neg_Big : Big_Integer;
+   Pos_One, Pos_Small, Pos_Big : Big_Integer;
+   Corrupted                   : Big_Integer;
+begin
+   Zero := 0;
+   Neg_One := -1;
+   Neg_Small := -1000;
+   Neg_Big := -1234567890_0987654321_1234567890_0987654321;
+   Pos_One := 1;
+   Pos_Small := 1000;
+   Pos_Big := 1234567890_0987654321_1234567890_0987654321;
+   Corrupted := Zero;  --  BREAK
+end Foo;

testsuite/tests/big-integers/test.py

@@ -0,0 +1,25 @@
+from support.build import gnatmake
+from support.gdb import GDBSession
+
+
+gnatmake('foo')
+gdb = GDBSession('foo')
+gdb.run_to(gdb.find_loc('foo.adb', 'BREAK'))
+
+gdb.execute('set corrupted.value.c := 0x1')
+
+gdb.print_expr('uninit', 'Big_Integer ([Uninitialized])')
+gdb.print_expr('zero', 'Big_Integer (0)')
+gdb.print_expr('neg_one', 'Big_Integer (-1)')
+gdb.print_expr('neg_small', 'Big_Integer (-1000)')
+gdb.print_expr(
+    'neg_big',
+    'Big_Integer (-1234567890098765432112345678900987654321)'
+)
+gdb.print_expr('pos_one', 'Big_Integer (1)')
+gdb.print_expr('pos_small', 'Big_Integer (1000)')
+gdb.print_expr(
+    'pos_big',
+    'Big_Integer (1234567890098765432112345678900987654321)'
+)
+gdb.print_expr('corrupted', 'Big_Integer ([Invalid])')

testsuite/tests/big-integers/test.yaml

@@ -0,0 +1 @@
+driver: python

testsuite/tests/big-reals/foo.adb

@@ -0,0 +1,21 @@
+pragma Ada_2022;
+
+with Ada.Numerics.Big_Numbers.Big_Integers;
+use Ada.Numerics.Big_Numbers.Big_Integers;
+with Ada.Numerics.Big_Numbers.Big_Reals;
+use Ada.Numerics.Big_Numbers.Big_Reals;
+
+procedure Foo is
+   Uninit, Zero       : Big_Real;
+   Neg_One, Neg_Small : Big_Real;
+   Pos_One, Pos_Small : Big_Real;
+   Corrupted          : Big_Real;
+begin
+   Zero := 0 / 5;
+   Neg_One := -1 / 1;
+   Neg_Small := 10 / (-9);
+   Pos_One := 6 / 6;
+   Pos_Small := 1000 / 3;
+   Corrupted := Pos_One;
+   Corrupted := Zero;  --  BREAK
+end Foo;

testsuite/tests/big-reals/test.py

@@ -0,0 +1,17 @@
+from support.build import gnatmake
+from support.gdb import GDBSession
+
+
+gnatmake('foo')
+gdb = GDBSession('foo')
+gdb.run_to(gdb.find_loc('foo.adb', 'BREAK'))
+
+gdb.execute('set corrupted.num.value.c := 0x1')
+
+gdb.print_expr('uninit', 'Big_Real ([Uninitialized])')
+gdb.print_expr('zero', 'Big_Real (0 / 1)')
+gdb.print_expr('neg_one', 'Big_Real (-1 / 1)')
+gdb.print_expr('neg_small', 'Big_Real (-10 / 9)')
+gdb.print_expr('pos_one', 'Big_Real (1 / 1)')
+gdb.print_expr('pos_small', 'Big_Real (1000 / 3)')
+gdb.print_expr('corrupted', 'Big_Real ([Invalid])')

testsuite/tests/big-reals/test.yaml

@@ -0,0 +1 @@
+driver: python