Enable querying constants and value kinds

ffi/value.cpp

@@ -309,6 +309,43 @@ LLVMPY_DisposeOperandsIter(LLVMOperandsIteratorRef GI) {
     delete llvm::unwrap(GI);
 }
 
+API_EXPORT(bool)
+LLVMPY_IsConstant(LLVMValueRef Val) { return LLVMIsConstant(Val); }
+
+API_EXPORT(const uint64_t *)
+LLVMPY_GetConstantIntRawValue(LLVMValueRef Val, bool *littleEndian) {
+    if (littleEndian) {
+        *littleEndian = llvm::sys::IsLittleEndianHost;
+    }
+    if (llvm::ConstantInt *CI =
+            llvm::dyn_cast<llvm::ConstantInt>((llvm::Value *)Val)) {
+        return CI->getValue().getRawData();
+    }
+    return nullptr;
+}
+
+API_EXPORT(unsigned)
+LLVMPY_GetConstantIntNumWords(LLVMValueRef Val) {
+    if (llvm::ConstantInt *CI =
+            llvm::dyn_cast<llvm::ConstantInt>((llvm::Value *)Val)) {
+        return CI->getValue().getNumWords();
+    }
+    return 0;
+}
+
+API_EXPORT(double)
+LLVMPY_GetConstantFPValue(LLVMValueRef Val, bool *losesInfo) {
+    LLVMBool losesInfo_internal;
+    double result = LLVMConstRealGetDouble(Val, &losesInfo_internal);
+    if (losesInfo) {
+        *losesInfo = losesInfo_internal;
+    }
+    return result;
+}
+
+API_EXPORT(int)
+LLVMPY_GetValueKind(LLVMValueRef Val) { return (int)LLVMGetValueKind(Val); }
+
 API_EXPORT(void)
 LLVMPY_PrintValueToString(LLVMValueRef Val, const char **outstr) {
     *outstr = LLVMPrintValueToString(Val);

llvmlite/binding/value.py

@@ -1,5 +1,7 @@
-from ctypes import POINTER, c_char_p, c_int, c_size_t, c_uint, c_bool, c_void_p
+from ctypes import (POINTER, byref, cast, c_char_p, c_double, c_int, c_size_t,
+                    c_uint, c_uint64, c_bool, c_void_p)
 import enum
+import warnings
 
 from llvmlite.binding import ffi
 from llvmlite.binding.common import _decode_string, _encode_string
@@ -43,6 +45,41 @@ class StorageClass(enum.IntEnum):
     dllexport = 2
 
 
+class ValueKind(enum.IntEnum):
+    # The LLVMValueKind enum from llvm-c/Core.h
+
+    argument = 0
+    basic_block = 1
+    memory_use = 2
+    memory_def = 3
+    memory_phi = 4
+
+    function = 5
+    global_alias = 6
+    global_ifunc = 7
+    global_variable = 8
+    block_address = 9
+    constant_expr = 10
+    constant_array = 11
+    constant_struct = 12
+    constant_vector = 13
+
+    undef_value = 14
+    constant_aggregate_zero = 15
+    constant_data_array = 16
+    constant_data_vector = 17
+    constant_int = 18
+    constant_fp = 19
+    constant_pointer_null = 20
+    constant_token_none = 21
+
+    metadata_as_value = 22
+    inline_asm = 23
+
+    instruction = 24
+    poison_value = 25
+
+
 class TypeRef(ffi.ObjectRef):
     """A weak reference to a LLVM type
     """
@@ -140,6 +177,14 @@ def is_instruction(self):
     def is_operand(self):
         return self._kind == 'operand'
 
+    @property
+    def is_constant(self):
+        return bool(ffi.lib.LLVMPY_IsConstant(self))
+
+    @property
+    def value_kind(self):
+        return ValueKind(ffi.lib.LLVMPY_GetValueKind(self))
+
     @property
     def name(self):
         return _decode_string(ffi.lib.LLVMPY_GetValueName(self))
@@ -299,6 +344,43 @@ def opcode(self):
                              % (self._kind,))
         return ffi.ret_string(ffi.lib.LLVMPY_GetOpcodeName(self))
 
+    def get_constant_value(self):
+        """
+        Return the constant value, either as a literal (when supported)
+        or as a string.
+        """
+        if not self.is_constant:
+            raise ValueError('expected constant value, got %s'
+                             % (self._kind,))
+
+        if self.value_kind == ValueKind.constant_int:
+            # Python integers are also arbitrary-precision
+            little_endian = c_bool(False)
+            words = ffi.lib.LLVMPY_GetConstantIntNumWords(self)
+            ptr = ffi.lib.LLVMPY_GetConstantIntRawValue(
+                self, byref(little_endian))
+            asbytes = bytes(cast(ptr, POINTER(c_uint64 * words)).contents)
+            return int.from_bytes(
+                asbytes,
+                ('little' if little_endian.value else 'big'),
+                signed=False,
+            )
+        elif self.value_kind == ValueKind.constant_fp:
+            # Convert floating-point values to double (Python float)
+            accuracy_loss = c_bool(False)
+            value = ffi.lib.LLVMPY_GetConstantFPValue(self,
+                                                      byref(accuracy_loss))
+            if accuracy_loss.value:
+                warnings.warn(
+                    'Accuracy loss encountered in conversion of constant '
+                    f'value {str(self)}'
+                )
+
+            return value
+
+        # Otherwise, return the IR string
+        return str(self)
+
 
 class _ValueIterator(ffi.ObjectRef):
 
@@ -516,3 +598,20 @@ def _next(self):
 
 ffi.lib.LLVMPY_GetOpcodeName.argtypes = [ffi.LLVMValueRef]
 ffi.lib.LLVMPY_GetOpcodeName.restype = c_void_p
+
+ffi.lib.LLVMPY_IsConstant.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_IsConstant.restype = c_bool
+
+ffi.lib.LLVMPY_GetValueKind.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetValueKind.restype = c_int
+
+ffi.lib.LLVMPY_GetConstantIntRawValue.argtypes = [ffi.LLVMValueRef,
+                                                  POINTER(c_bool)]
+ffi.lib.LLVMPY_GetConstantIntRawValue.restype = POINTER(c_uint64)
+
+ffi.lib.LLVMPY_GetConstantIntNumWords.argtypes = [ffi.LLVMValueRef]
+ffi.lib.LLVMPY_GetConstantIntNumWords.restype = c_uint
+
+ffi.lib.LLVMPY_GetConstantFPValue.argtypes = [ffi.LLVMValueRef,
+                                              POINTER(c_bool)]
+ffi.lib.LLVMPY_GetConstantFPValue.restype = c_double

llvmlite/tests/test_binding.py

@@ -63,6 +63,18 @@ def no_de_locale():
     }}
     """
 
+asm_sum3 = r"""
+    ; ModuleID = '<string>'
+    target triple = "{triple}"
+
+    define i64 @sum(i64 %.1, i64 %.2) {{
+      %.3 = add i64 %.1, %.2
+      %.4 = add i64 5, %.3
+      %.5 = add i64 -5, %.4
+      ret i64 %.5
+    }}
+    """
+
 asm_mul = r"""
     ; ModuleID = '<string>'
     target triple = "{triple}"
@@ -1280,6 +1292,77 @@ def test_function_attributes(self):
                 self.assertEqual(list(args[0].attributes), [b'returned'])
                 self.assertEqual(list(args[1].attributes), [])
 
+    def test_value_kind(self):
+        mod = self.module()
+        self.assertEqual(mod.get_global_variable('glob').value_kind,
+                         llvm.ValueKind.global_variable)
+        func = mod.get_function('sum')
+        self.assertEqual(func.value_kind, llvm.ValueKind.function)
+        block = list(func.blocks)[0]
+        self.assertEqual(block.value_kind, llvm.ValueKind.basic_block)
+        inst = list(block.instructions)[1]
+        self.assertEqual(inst.value_kind, llvm.ValueKind.instruction)
+        self.assertEqual(list(inst.operands)[0].value_kind,
+                         llvm.ValueKind.constant_int)
+        self.assertEqual(list(inst.operands)[1].value_kind,
+                         llvm.ValueKind.instruction)
+
+        iasm_func = self.module(asm_inlineasm).get_function('foo')
+        iasm_inst = list(list(iasm_func.blocks)[0].instructions)[0]
+        self.assertEqual(list(iasm_inst.operands)[0].value_kind,
+                         llvm.ValueKind.inline_asm)
+
+    def test_is_constant(self):
+        mod = self.module()
+        self.assertTrue(mod.get_global_variable('glob').is_constant)
+        constant_operands = 0
+        for func in mod.functions:
+            self.assertTrue(func.is_constant)
+            for block in func.blocks:
+                self.assertFalse(block.is_constant)
+                for inst in block.instructions:
+                    self.assertFalse(inst.is_constant)
+                    for op in inst.operands:
+                        if op.is_constant:
+                            constant_operands += 1
+
+        self.assertEqual(constant_operands, 1)
+
+    def test_constant_int(self):
+        mod = self.module()
+        func = mod.get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(insts[1].opcode, 'add')
+        operands = list(insts[1].operands)
+        self.assertTrue(operands[0].is_constant)
+        self.assertFalse(operands[1].is_constant)
+        self.assertEqual(operands[0].get_constant_value(), 0)
+
+        mod = self.module(asm_sum3)
+        func = mod.get_function('sum')
+        insts = list(list(func.blocks)[0].instructions)
+        posint64 = list(insts[1].operands)[0]
+        negint64 = list(insts[2].operands)[0]
+        self.assertEqual(posint64.get_constant_value(), 5)
+
+        # Convert from unsigned arbitrary-precision integer to signed i64
+        as_u64 = negint64.get_constant_value()
+        as_i64 = int.from_bytes(as_u64.to_bytes(8, 'little'), 'little',
+                                signed=True)
+        self.assertEqual(as_i64, -5)
+
+    def test_constant_fp(self):
+        mod = self.module(asm_double_locale)
+        func = mod.get_function('foo')
+        insts = list(list(func.blocks)[0].instructions)
+        self.assertEqual(len(insts), 2)
+        self.assertEqual(insts[0].opcode, 'fadd')
+        operands = list(insts[0].operands)
+        self.assertTrue(operands[0].is_constant)
+        self.assertAlmostEqual(operands[0].get_constant_value(), 0.0)
+        self.assertTrue(operands[1].is_constant)
+        self.assertAlmostEqual(operands[1].get_constant_value(), 3.14)
+
 
 class TestTarget(BaseTest):