inspection methods on runtime

Author: William Grant

typed_python/compiler/native_ast_to_llvm.py

@@ -1498,7 +1498,6 @@ def __init__(self):
         self._inlineRequests = []
 
         self._printAllNativeCalls = os.getenv("TP_COMPILER_LOG_NATIVE_CALLS")
-        self._native_ast_str = ""
         self.verbose = False
 
     def markExternal(self, functionNameToType):
@@ -1576,28 +1575,30 @@ def add_functions(self, names_to_definitions):
             )
             func_type = llvmlite.ir.FunctionType(
                 type_to_llvm_type(function.output_type),
-                [type_to_llvm_type(x[1]) for x in function.args],
-            )
-            self._functions_by_name[name] = llvmlite.ir.Function(
-                module, func_type, name
+                [type_to_llvm_type(x[1]) for x in function.args]
             )
+            self._functions_by_name[name] = llvmlite.ir.Function(module, func_type, name)
 
-            self._functions_by_name[name].linkage = "external"
+            self._functions_by_name[name].linkage = 'external'
             self._function_definitions[name] = function
 
-            self._native_ast_str += "\n"
-            self._native_ast_str += "*************\n"
-            self._native_ast_str += "def %s(%s): #->%s\n" % (
-                name,
-                ",".join(["%s=%s" % (k, str(t)) for k, t in function.args]),
-                str(function.output_type),
-            )
-            self._native_ast_str += native_ast.indent(str(function.body.body)) + "\n"
-            self._native_ast_str += "*************\n"
-            self._native_ast_str += "\n"
-
         if self.verbose:
-            print(self._native_ast_str)
+            for name in names_to_definitions:
+                definition = names_to_definitions[name]
+                func = self._functions_by_name[name]
+
+                print()
+                print("*************")
+                print(
+                    "def %s(%s): #->%s" % (
+                        name,
+                        ",".join(["%s=%s" % (k, str(t)) for k, t in definition.args]),
+                        str(definition.output_type)
+                    )
+                )
+                print(native_ast.indent(str(definition.body.body)))
+                print("*************")
+                print()
 
         globalDefinitions = {}
         globalDefinitionsLlvmValues = {}

typed_python/compiler/runtime.py

@@ -465,3 +465,88 @@ def Compiled(pyFunc):
     f.resultTypeFor(*types)
 
     return f
+
+
+def getNativeIRCode(typedFunc: Function) -> str:
+    """
+    Given a function compiled with Entrypoint, return a text representation
+    of the generated native (one layer prior to LLVM) code.
+
+    Args:
+        typedFunc (Function): a decorated python function.
+
+    Returns:
+        A string for the function bodies generated (including constructors and destructors)
+    """
+    converter = Runtime.singleton().llvm_compiler.converter
+    function_name = typedFunc.__name__
+    # relies on us maintaining our naming conventions (tests would break otherwise)
+    output_str = ""
+    for key, value in converter._function_definitions.items():
+        if function_name in key:
+            output_str += f'Function {key}' + '_'*20 + '\n'
+            output_str += str(value.body.body) + '\n'
+            output_str += "_"*80 + '\n'
+
+    if not output_str:
+        raise ValueError('no matching function definitions found - has the code been compiled (and run)?')
+
+    return output_str
+
+
+def getNativeIRString(typedFunc: Function) -> str:
+    """
+    Given a function compiled with Entrypoint, return a text representation
+    of the generated native (one layer prior to LLVM) code.
+
+    Args:
+        typedFunc (Function): a decorated python function.
+
+    Returns:
+        A string for the function bodies generated (including constructors and destructors)
+    """
+    converter = Runtime.singleton().llvm_compiler.converter
+    function_name = typedFunc.__name__
+    # relies on us maintaining our naming conventions (tests would break otherwise)
+    output_str = ""
+    for key, value in converter._function_definitions.items():
+        if function_name in key:
+            output_str += f"Function {key}" + "_" * 20 + "\n"
+            output_str += str(value.body.body) + "\n"
+            output_str += "_" * 80 + "\n"
+
+    if not output_str:
+        raise ValueError(
+            "no matching function definitions found - has the code been compiled (and run)?"
+        )
+
+    return output_str
+
+
+def getLLVMString(typedFunc: Function) -> str:
+    """
+    Given a function compiled with Entrypoint, return a text representation
+    of the generated LLVM code.
+
+    Args:
+        typedFunc (Function): a decorated python function.
+
+    Returns:
+        A string for the function bodies generated (including constructors and destructors)
+    """
+    converter = Runtime.singleton().llvm_compiler.converter
+    function_name = typedFunc.__name__
+    # relies on us maintaining our naming conventions (tests would break otherwise)
+    output_str = ""
+    for key, value in converter._functions_by_name.items():
+        if function_name in key:
+            output_str += f"Function {key}" + "_" * 20 + "\n"
+            output_str += str(value) + "\n"
+            output_str += "_" * 80 + "\n"
+
+    if not output_str:
+        raise ValueError(
+            "no matching function definitions found - has the code been compiled (and run)?"
+        )
+
+    return output_str