Spaces:
Running
Running
| from ctypes import c_bool, c_int, c_size_t, POINTER, Structure, byref, c_char_p | |
| from collections import namedtuple | |
| from enum import IntFlag | |
| from llvmlite.binding import ffi | |
| def create_new_module_pass_manager(): | |
| return ModulePassManager() | |
| def create_new_function_pass_manager(): | |
| return FunctionPassManager() | |
| def create_pass_builder(tm, pto): | |
| return PassBuilder(tm, pto) | |
| def create_pipeline_tuning_options(speed_level=2, size_level=0): | |
| return PipelineTuningOptions(speed_level, size_level) | |
| _prunestats = namedtuple('PruneStats', | |
| ('basicblock diamond fanout fanout_raise')) | |
| class PruneStats(_prunestats): | |
| """ Holds statistics from reference count pruning. | |
| """ | |
| def __add__(self, other): | |
| if not isinstance(other, PruneStats): | |
| msg = 'PruneStats can only be added to another PruneStats, got {}.' | |
| raise TypeError(msg.format(type(other))) | |
| return PruneStats(self.basicblock + other.basicblock, | |
| self.diamond + other.diamond, | |
| self.fanout + other.fanout, | |
| self.fanout_raise + other.fanout_raise) | |
| def __sub__(self, other): | |
| if not isinstance(other, PruneStats): | |
| msg = ('PruneStats can only be subtracted from another PruneStats, ' | |
| 'got {}.') | |
| raise TypeError(msg.format(type(other))) | |
| return PruneStats(self.basicblock - other.basicblock, | |
| self.diamond - other.diamond, | |
| self.fanout - other.fanout, | |
| self.fanout_raise - other.fanout_raise) | |
| class _c_PruneStats(Structure): | |
| _fields_ = [ | |
| ('basicblock', c_size_t), | |
| ('diamond', c_size_t), | |
| ('fanout', c_size_t), | |
| ('fanout_raise', c_size_t)] | |
| def dump_refprune_stats(printout=False): | |
| """ Returns a namedtuple containing the current values for the refop pruning | |
| statistics. If kwarg `printout` is True the stats are printed to stderr, | |
| default is False. | |
| """ | |
| stats = _c_PruneStats(0, 0, 0, 0) | |
| do_print = c_bool(printout) | |
| ffi.lib.LLVMPY_DumpRefPruneStats(byref(stats), do_print) | |
| return PruneStats(stats.basicblock, stats.diamond, stats.fanout, | |
| stats.fanout_raise) | |
| # TODO: Rename and add tests for these | |
| # Although new pass manager has its own timing APIs, we still need to support | |
| # the legacy ones as LLVM backend still used the LegacyPassManager. These APIs | |
| # will be used to time the backend passes such as instruction selection, | |
| # regalloc, etc | |
| def set_time_passes(enable): | |
| """Enable or disable the pass timers. | |
| Parameters | |
| ---------- | |
| enable : bool | |
| Set to True to enable the pass timers. | |
| Set to False to disable the pass timers. | |
| """ | |
| ffi.lib.LLVMPY_SetTimePasses(c_bool(enable)) | |
| def report_and_reset_timings(): | |
| """Returns the pass timings report and resets the LLVM internal timers. | |
| Pass timers are enabled by ``set_time_passes()``. If the timers are not | |
| enabled, this function will return an empty string. | |
| Returns | |
| ------- | |
| res : str | |
| LLVM generated timing report. | |
| """ | |
| with ffi.OutputString() as buf: | |
| ffi.lib.LLVMPY_ReportAndResetTimings(buf) | |
| return str(buf) | |
| class RefPruneSubpasses(IntFlag): | |
| PER_BB = 0b0001 # noqa: E221 | |
| DIAMOND = 0b0010 # noqa: E221 | |
| FANOUT = 0b0100 # noqa: E221 | |
| FANOUT_RAISE = 0b1000 | |
| ALL = PER_BB | DIAMOND | FANOUT | FANOUT_RAISE | |
| class NewPassManager(): | |
| def __init__(self): | |
| if type(self) is NewPassManager: | |
| raise TypeError("Cannot instantiate NewPassManager directly") | |
| def run(self,IR, pb): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_RunNewModulePassManager(self, IR, pb) | |
| else: | |
| ffi.lib.LLVMPY_RunNewFunctionPassManager(self, IR, pb) | |
| def add_aa_eval_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddAAEvaluator(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddAAEvaluator(self) | |
| def add_simplify_cfg_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddSimplifyCFGPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddSimplifyCFGPass(self) | |
| def add_loop_unroll_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLoopUnrollPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLoopUnrollPass(self) | |
| def add_instruction_combine_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddInstCombinePass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddInstCombinePass(self) | |
| def add_jump_threading_pass(self, threshold=-1): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_AddJumpThreadingPass_module(self, threshold) | |
| else: | |
| ffi.lib.LLVMPY_AddJumpThreadingPass_function(self, threshold) | |
| def add_cfg_printer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddCFGPrinterPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddCFGPrinterPass(self) | |
| def add_cfg_only_printer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddCFGOnlyPrinterPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddCFGOnlyPrinterPass(self) | |
| def add_dom_printer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddDomPrinter(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddDomPrinter(self) | |
| def add_dom_only_printer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddDomOnlyPrinter(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddDomOnlyPrinter(self) | |
| def add_post_dom_printer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddPostDomPrinter(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddPostDomPrinter(self) | |
| def add_post_dom_only_printer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddPostDomOnlyPrinter(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddPostDomOnlyPrinter(self) | |
| def add_dom_viewer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddDomViewer(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddDomViewer(self) | |
| def add_dom_only_viewer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddDomOnlyViewer(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddDomOnlyViewer(self) | |
| def add_post_dom_viewer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddPostDomViewer(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddPostDomViewer(self) | |
| def add_post_dom_only_viewer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddPostDomOnlyViewer(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddPostDomOnlyViewer(self) | |
| def add_lint_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLintPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLintPass(self) | |
| def add_aggressive_dce_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddADCEPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddADCEPass(self) | |
| def add_break_critical_edges_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddBreakCriticalEdgesPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddBreakCriticalEdgesPass(self) | |
| def add_dead_store_elimination_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddDSEPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddDSEPass(self) | |
| def add_dead_code_elimination_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddDCEPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddDCEPass(self) | |
| def add_aggressive_instcombine_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddAggressiveInstCombinePass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddAggressiveInstCombinePass(self) | |
| def add_lcssa_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLCSSAPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLCSSAPass(self) | |
| def add_new_gvn_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddNewGVNPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddNewGVNPass(self) | |
| def add_loop_simplify_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLoopSimplifyPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLoopSimplifyPass(self) | |
| def add_loop_unroll_and_jam_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLoopUnrollAndJamPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLoopUnrollAndJamPass(self) | |
| def add_sccp_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddSCCPPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddSCCPPass(self) | |
| def add_lower_atomic_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLowerAtomicPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLowerAtomicPass(self) | |
| def add_lower_invoke_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLowerInvokePass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLowerInvokePass(self) | |
| def add_lower_switch_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLowerSwitchPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLowerSwitchPass(self) | |
| def add_mem_copy_opt_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddMemCpyOptPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddMemCpyOptPass(self) | |
| def add_unify_function_exit_nodes_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddUnifyFunctionExitNodesPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddUnifyFunctionExitNodesPass(self) | |
| def add_reassociate_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddReassociatePass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddReassociatePass(self) | |
| def add_register_to_memory_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddRegToMemPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddRegToMemPass(self) | |
| def add_sroa_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddSROAPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddSROAPass(self) | |
| def add_sinking_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddSinkingPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddSinkingPass(self) | |
| def add_tail_call_elimination_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddTailCallElimPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddTailCallElimPass(self) | |
| def add_instruction_namer_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddInstructionNamerPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddInstructionNamerPass(self) | |
| def add_loop_deletion_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLoopDeletionPass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLoopDeletionPass(self) | |
| def add_loop_strength_reduce_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLoopStrengthReducePass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLoopStrengthReducePass(self) | |
| def add_loop_rotate_pass(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_module_AddLoopRotatePass(self) | |
| else: | |
| ffi.lib.LLVMPY_function_AddLoopRotatePass(self) | |
| def _dispose(self): | |
| if isinstance(self, ModulePassManager): | |
| ffi.lib.LLVMPY_DisposeNewModulePassManger(self) | |
| else: | |
| ffi.lib.LLVMPY_DisposeNewFunctionPassManger(self) | |
| class ModulePassManager(ffi.ObjectRef, NewPassManager): | |
| def __init__(self, ptr=None): | |
| if ptr is None: | |
| ptr = ffi.lib.LLVMPY_CreateNewModulePassManager() | |
| super().__init__(ptr) | |
| def add_verifier(self): | |
| ffi.lib.LLVMPY_module_AddVerifierPass(self) | |
| def add_constant_merge_pass(self): | |
| ffi.lib.LLVMPY_module_AddConstantMergePass(self) | |
| def add_dead_arg_elimination_pass(self): | |
| ffi.lib.LLVMPY_module_AddDeadArgumentEliminationPass(self) | |
| def add_dot_call_graph_printer_pass(self): | |
| ffi.lib.LLVMPY_module_AddCallGraphDOTPrinterPass(self) | |
| # TODO: There are a lot more printer passes in llvm that can be exposed | |
| # FIXME: Find a way to write the output to a buffer instead of stdout | |
| def add_module_debug_info_pass(self): | |
| ffi.lib.LLVMPY_module_AddModuleDebugInfoPrinterPass(self) | |
| def add_always_inliner_pass(self): | |
| ffi.lib.LLVMPY_module_AddAlwaysInlinerPass(self) | |
| def add_rpo_function_attrs_pass(self): | |
| ffi.lib.LLVMPY_module_AddReversePostOrderFunctionAttrsPass(self) | |
| def add_global_dead_code_eliminate_pass(self): | |
| ffi.lib.LLVMPY_module_AddGlobalDCEPass(self) | |
| def add_global_opt_pass(self): | |
| ffi.lib.LLVMPY_module_AddGlobalOptPass(self) | |
| def add_ipsccp_pass(self): | |
| ffi.lib.LLVMPY_module_AddIPSCCPPass(self) | |
| def add_internalize_pass(self): | |
| ffi.lib.LLVMPY_module_AddInternalizePass(self) | |
| def add_loop_extract_pass(self): | |
| ffi.lib.LLVMPY_module_AddLoopExtractorPass(self) | |
| def add_merge_functions_pass(self): | |
| ffi.lib.LLVMPY_module_AddMergeFunctionsPass(self) | |
| def add_partial_inliner_pass(self): | |
| ffi.lib.LLVMPY_module_AddPartialInlinerPass(self) | |
| def add_strip_symbols_pass(self): | |
| ffi.lib.LLVMPY_module_AddStripSymbolsPass(self) | |
| def add_strip_dead_debug_info_pass(self): | |
| ffi.lib.LLVMPY_module_AddStripDeadDebugInfoPass(self) | |
| def add_strip_dead_prototype_pass(self): | |
| ffi.lib.LLVMPY_module_AddStripDeadPrototypesPass(self) | |
| def add_strip_debug_declare_pass(self): | |
| ffi.lib.LLVMPY_module_AddStripDebugDeclarePass(self) | |
| def add_strip_non_debug_symbols_pass(self): | |
| ffi.lib.LLVMPY_module_AddStripNonDebugSymbolsPass(self) | |
| def add_argument_promotion_pass(self): | |
| ffi.lib.LLVMPY_module_AddArgumentPromotionPass(self) | |
| def add_post_order_function_attributes_pass(self): | |
| ffi.lib.LLVMPY_module_AddPostOrderFunctionAttrsPass(self) | |
| # Non-standard LLVM passes | |
| def add_refprune_pass(self, subpasses_flags=RefPruneSubpasses.ALL, | |
| subgraph_limit=1000): | |
| """Add Numba specific Reference count pruning pass. | |
| Parameters | |
| ---------- | |
| subpasses_flags : RefPruneSubpasses | |
| A bitmask to control the subpasses to be enabled. | |
| subgraph_limit : int | |
| Limit the fanout pruners to working on a subgraph no bigger than | |
| this number of basic-blocks to avoid spending too much time in very | |
| large graphs. Default is 1000. Subject to change in future | |
| versions. | |
| """ | |
| iflags = RefPruneSubpasses(subpasses_flags) | |
| ffi.lib.LLVMPY_AddRefPrunePass_module(self, iflags, subgraph_limit) | |
| class FunctionPassManager(ffi.ObjectRef, NewPassManager): | |
| def __init__(self, ptr=None): | |
| if ptr is None: | |
| ptr = ffi.lib.LLVMPY_CreateNewFunctionPassManager() | |
| super().__init__(ptr) | |
| # Non-standard LLVM passes | |
| def add_refprune_pass(self, subpasses_flags=RefPruneSubpasses.ALL, | |
| subgraph_limit=1000): | |
| """Add Numba specific Reference count pruning pass. | |
| Parameters | |
| ---------- | |
| subpasses_flags : RefPruneSubpasses | |
| A bitmask to control the subpasses to be enabled. | |
| subgraph_limit : int | |
| Limit the fanout pruners to working on a subgraph no bigger than | |
| this number of basic-blocks to avoid spending too much time in very | |
| large graphs. Default is 1000. Subject to change in future | |
| versions. | |
| """ | |
| iflags = RefPruneSubpasses(subpasses_flags) | |
| ffi.lib.LLVMPY_AddRefPrunePass_function(self, iflags, subgraph_limit) | |
| class PipelineTuningOptions(ffi.ObjectRef): | |
| def __init__(self, speed_level=2, size_level=0): | |
| self._speed_level = None | |
| self._size_level = None | |
| self.speed_level = speed_level | |
| self.size_level = size_level | |
| super().__init__(ffi.lib.LLVMPY_CreatePipelineTuningOptions()) | |
| def speed_level(self): | |
| return self._speed_level | |
| def speed_level(self, value): | |
| if not 0 <= value <= 3: | |
| raise ValueError( | |
| "Optimization level for speed should be 0, 1, 2, or 3") | |
| self._speed_level = value | |
| def size_level(self): | |
| return self._size_level | |
| def size_level(self, value): | |
| if not 0 <= value <= 2: | |
| raise ValueError("Optimization level for size should be 0, 1, or 2") | |
| if value != 0 and self.speed_level != 2: | |
| raise ValueError( | |
| "Optimization for size should be encoded with speed level == 2") | |
| self._size_level = value | |
| def loop_interleaving(self): | |
| return ffi.lib.LLVMPY_PTOGetLoopInterleaving(self) | |
| def loop_interleaving(self, value): | |
| ffi.lib.LLVMPY_PTOSetLoopInterleaving(self, value) | |
| def loop_vectorization(self): | |
| return ffi.lib.LLVMPY_PTOGetLoopVectorization(self) | |
| def loop_vectorization(self, value): | |
| ffi.lib.LLVMPY_PTOSetLoopVectorization(self, value) | |
| def slp_vectorization(self): | |
| return ffi.lib.LLVMPY_PTOGetSLPVectorization(self) | |
| def slp_vectorization(self, value): | |
| ffi.lib.LLVMPY_PTOSetSLPVectorization(self, value) | |
| def loop_unrolling(self): | |
| return ffi.lib.LLVMPY_PTOGetLoopUnrolling(self) | |
| def loop_unrolling(self, value): | |
| ffi.lib.LLVMPY_PTOSetLoopUnrolling(self, value) | |
| def inlining_threshold(self): | |
| return ffi.lib.LLVMPY_PTOGetInlinerThreshold(self) | |
| def inlining_threshold(self, value): | |
| ffi.lib.LLVMPY_PTOSetInlinerThreshold(self, value) | |
| def _dispose(self): | |
| ffi.lib.LLVMPY_DisposePipelineTuningOptions(self) | |
| class TimePassesHandler(ffi.ObjectRef): | |
| def __init__(self): | |
| super().__init__(ffi.lib.LLVMPY_CreateTimePassesHandler()) | |
| def _dispose(self): | |
| ffi.lib.LLVMPY_DisposeTimePassesHandler(self) | |
| class PassBuilder(ffi.ObjectRef): | |
| def __init__(self, tm, pto): | |
| super().__init__(ffi.lib.LLVMPY_CreatePassBuilder(tm, pto)) | |
| self._pto = pto | |
| self._tm = tm | |
| self._time_passes_handler = None | |
| def getModulePassManager(self): | |
| return ModulePassManager( | |
| ffi.lib.LLVMPY_buildPerModuleDefaultPipeline( | |
| self, self._pto.speed_level, self._pto.size_level) | |
| ) | |
| def getFunctionPassManager(self): | |
| return FunctionPassManager( | |
| ffi.lib.LLVMPY_buildFunctionSimplificationPipeline( | |
| self, self._pto.speed_level, self._pto.size_level) | |
| ) | |
| def start_pass_timing(self): | |
| """Enable the pass timers. | |
| Raises | |
| ------ | |
| RuntimeError | |
| If pass timing is already enabled. | |
| """ | |
| if self._time_passes_handler: | |
| raise RuntimeError("Pass timing can only be done once") | |
| self._time_passes_handler = TimePassesHandler() | |
| ffi.lib.LLVMPY_EnableTimePasses(self, self._time_passes_handler) | |
| def finish_pass_timing(self): | |
| """Returns the pass timings report and disables the LLVM internal | |
| timers. Pass timers are enabled by ``start_pass_timing()``. If the | |
| timers are not enabled, this function will return an empty string. | |
| Returns | |
| ------- | |
| res : str | |
| LLVM generated timing report. | |
| """ | |
| if not self._time_passes_handler: | |
| raise RuntimeError("Pass timing is not enabled") | |
| with ffi.OutputString() as buf: | |
| ffi.lib.LLVMPY_ReportAndDisableTimePasses( | |
| self._time_passes_handler, buf) | |
| return str(buf) | |
| def _dispose(self): | |
| ffi.lib.LLVMPY_DisposePassBuilder(self) | |
| # ============================================================================ | |
| # FFI | |
| ffi.lib.LLVMPY_DumpRefPruneStats.argtypes = [POINTER(_c_PruneStats), c_bool] | |
| ffi.lib.LLVMPY_SetTimePasses.argtypes = [c_bool] | |
| ffi.lib.LLVMPY_ReportAndResetTimings.argtypes = [POINTER(c_char_p)] | |
| # ModulePassManager | |
| ffi.lib.LLVMPY_CreateNewModulePassManager.restype = ffi.LLVMModulePassManagerRef | |
| ffi.lib.LLVMPY_RunNewModulePassManager.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ffi.LLVMModuleRef, | |
| ffi.LLVMPassBuilderRef,] | |
| ffi.lib.LLVMPY_module_AddVerifierPass.argtypes = [ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddAAEvaluator.argtypes = [ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddSimplifyCFGPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLoopUnrollPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLoopRotatePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddInstCombinePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_AddJumpThreadingPass_module.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddCFGPrinterPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddCFGOnlyPrinterPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddDomPrinter.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddDomOnlyPrinter.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddPostDomPrinter.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddPostDomOnlyPrinter.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddDomViewer.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddDomOnlyViewer.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddPostDomViewer.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddPostDomOnlyViewer.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLintPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddADCEPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddBreakCriticalEdgesPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddDSEPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddDCEPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddAggressiveInstCombinePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLCSSAPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddNewGVNPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLoopSimplifyPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLoopUnrollAndJamPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddSCCPPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLowerAtomicPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLowerInvokePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLowerSwitchPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddMemCpyOptPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddUnifyFunctionExitNodesPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddReassociatePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddRegToMemPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddSROAPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddSinkingPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddTailCallElimPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddInstructionNamerPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLoopDeletionPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddLoopStrengthReducePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_module_AddConstantMergePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddDeadArgumentEliminationPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddCallGraphDOTPrinterPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddModuleDebugInfoPrinterPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddAlwaysInlinerPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddReversePostOrderFunctionAttrsPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddGlobalDCEPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddGlobalOptPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddIPSCCPPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddInternalizePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddLoopExtractorPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddMergeFunctionsPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddPartialInlinerPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddStripSymbolsPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddStripDeadDebugInfoPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddStripDeadPrototypesPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddStripDebugDeclarePass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddStripNonDebugSymbolsPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddArgumentPromotionPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_module_AddPostOrderFunctionAttrsPass.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, ] | |
| ffi.lib.LLVMPY_DisposeNewModulePassManger.argtypes = [ | |
| ffi.LLVMModulePassManagerRef,] | |
| ffi.lib.LLVMPY_AddRefPrunePass_module.argtypes = [ | |
| ffi.LLVMModulePassManagerRef, c_int, c_size_t, | |
| ] | |
| # FunctionPassManager | |
| ffi.lib.LLVMPY_CreateNewFunctionPassManager.restype = \ | |
| ffi.LLVMFunctionPassManagerRef | |
| ffi.lib.LLVMPY_RunNewFunctionPassManager.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ffi.LLVMValueRef, | |
| ffi.LLVMPassBuilderRef,] | |
| ffi.lib.LLVMPY_function_AddAAEvaluator.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef,] | |
| ffi.lib.LLVMPY_function_AddSimplifyCFGPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef,] | |
| ffi.lib.LLVMPY_function_AddLoopUnrollPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef,] | |
| ffi.lib.LLVMPY_function_AddInstCombinePass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef,] | |
| ffi.lib.LLVMPY_AddJumpThreadingPass_function.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, c_int,] | |
| ffi.lib.LLVMPY_function_AddCFGPrinterPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddCFGOnlyPrinterPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddDomPrinter.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddDomOnlyPrinter.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddPostDomPrinter.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddPostDomOnlyPrinter.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddDomViewer.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddDomOnlyViewer.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddPostDomViewer.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddPostDomOnlyViewer.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLintPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddADCEPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddBreakCriticalEdgesPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddDSEPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddDCEPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddAggressiveInstCombinePass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLCSSAPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddNewGVNPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLoopSimplifyPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLoopUnrollAndJamPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddSCCPPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLowerAtomicPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLowerInvokePass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLowerSwitchPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddMemCpyOptPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddUnifyFunctionExitNodesPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddReassociatePass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddRegToMemPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddSROAPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddSinkingPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddTailCallElimPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddInstructionNamerPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLoopRotatePass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLoopDeletionPass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_function_AddLoopStrengthReducePass.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, ] | |
| ffi.lib.LLVMPY_DisposeNewFunctionPassManger.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef,] | |
| ffi.lib.LLVMPY_AddRefPrunePass_function.argtypes = [ | |
| ffi.LLVMFunctionPassManagerRef, c_int, c_size_t, | |
| ] | |
| # PipelineTuningOptions | |
| ffi.lib.LLVMPY_CreatePipelineTuningOptions.restype = \ | |
| ffi.LLVMPipelineTuningOptionsRef | |
| ffi.lib.LLVMPY_PTOGetLoopInterleaving.restype = c_bool | |
| ffi.lib.LLVMPY_PTOGetLoopInterleaving.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef,] | |
| ffi.lib.LLVMPY_PTOSetLoopInterleaving.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef, c_bool] | |
| ffi.lib.LLVMPY_PTOGetLoopVectorization.restype = c_bool | |
| ffi.lib.LLVMPY_PTOGetLoopVectorization.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef,] | |
| ffi.lib.LLVMPY_PTOSetLoopVectorization.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef, c_bool] | |
| ffi.lib.LLVMPY_PTOGetSLPVectorization.restype = c_bool | |
| ffi.lib.LLVMPY_PTOGetSLPVectorization.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef,] | |
| ffi.lib.LLVMPY_PTOSetSLPVectorization.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef, c_bool] | |
| ffi.lib.LLVMPY_PTOGetLoopUnrolling.restype = c_bool | |
| ffi.lib.LLVMPY_PTOGetLoopUnrolling.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef,] | |
| ffi.lib.LLVMPY_PTOSetLoopUnrolling.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef, c_bool] | |
| ffi.lib.LLVMPY_PTOGetInlinerThreshold.restype = c_int | |
| ffi.lib.LLVMPY_PTOSetInlinerThreshold.argtypes = [ | |
| ffi.LLVMPipelineTuningOptionsRef, c_int] | |
| ffi.lib.LLVMPY_DisposePipelineTuningOptions.argtypes = \ | |
| [ffi.LLVMPipelineTuningOptionsRef,] | |
| # PassBuilder | |
| ffi.lib.LLVMPY_CreatePassBuilder.restype = ffi.LLVMPassBuilderRef | |
| ffi.lib.LLVMPY_CreatePassBuilder.argtypes = [ | |
| ffi.LLVMTargetMachineRef, | |
| ffi.LLVMPipelineTuningOptionsRef, | |
| ] | |
| ffi.lib.LLVMPY_DisposePassBuilder.argtypes = [ffi.LLVMPassBuilderRef,] | |
| ffi.lib.LLVMPY_CreateTimePassesHandler.restype = \ | |
| ffi.LLVMTimePassesHandlerRef | |
| ffi.lib.LLVMPY_DisposeTimePassesHandler.argtypes = [ | |
| ffi.LLVMTimePassesHandlerRef,] | |
| ffi.lib.LLVMPY_EnableTimePasses.argtypes = [ | |
| ffi.LLVMPassBuilderRef, | |
| ffi.LLVMTimePassesHandlerRef, | |
| ] | |
| ffi.lib.LLVMPY_ReportAndDisableTimePasses.argtypes = [ | |
| ffi.LLVMTimePassesHandlerRef, | |
| POINTER(c_char_p), | |
| ] | |
| # Pipeline builders | |
| ffi.lib.LLVMPY_buildPerModuleDefaultPipeline.restype = \ | |
| ffi.LLVMModulePassManagerRef | |
| ffi.lib.LLVMPY_buildPerModuleDefaultPipeline.argtypes = [ | |
| ffi.LLVMPassBuilderRef, c_int, c_int] | |
| ffi.lib.LLVMPY_buildFunctionSimplificationPipeline.restype = \ | |
| ffi.LLVMFunctionPassManagerRef | |
| ffi.lib.LLVMPY_buildFunctionSimplificationPipeline.argtypes = [ | |
| ffi.LLVMPassBuilderRef, c_int, c_int] | |