llvmlite 0.10.0__tar.gz → 0.12.0__tar.gz

{llvmlite-0.10.0 → llvmlite-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: llvmlite
-Version: 0.10.0
+Version: 0.12.0
 Summary: lightweight wrapper around basic LLVM functionality
 Home-page: http://llvmlite.pydata.org
 Author: Continuum Analytics, Inc.

{llvmlite-0.10.0 → llvmlite-0.12.0}/README.rst

@@ -50,7 +50,8 @@ Compatibility
 
 llvmlite works with Python 2.7 and Python 3.4 or greater.
 
-As of version 0.9, llvmlite requires LLVM 3.7.  It does not support earlier or later versions of LLVM.
+As of version 0.10, llvmlite requires LLVM 3.7.  It does not support earlier
+or later versions of LLVM.
 
 Documentation
 =============

{llvmlite-0.10.0 → llvmlite-0.12.0}/ffi/Makefile.freebsd

@@ -3,6 +3,7 @@ CXX = clang++ -std=c++11 -stdlib=libc++
 CXXFLAGS = $(LLVM_CXXFLAGS)
 LDFLAGS = $(LLVM_LDFLAGS)
 LIBS = $(LLVM_LIBS)
+INCLUDE = core.h
 SRC = assembly.cpp bitcode.cpp core.cpp initfini.cpp module.cpp value.cpp \
 	executionengine.cpp transforms.cpp passmanagers.cpp targets.cpp dylib.cpp \
 	linker.cpp
@@ -10,7 +11,7 @@ OUTPUT = libllvmlite.so
 
 all: $(OUTPUT)
 
-$(OUTPUT): $(SRC)
+$(OUTPUT): $(SRC) $(INCLUDE)
 	$(CXX) -shared $(CXXFLAGS) $(SRC) -o $(OUTPUT) $(LDFLAGS) $(LIBS)
 
 clean:

{llvmlite-0.10.0 → llvmlite-0.12.0}/ffi/Makefile.linux

@@ -8,6 +8,7 @@ LD_FLTO_FLAGS ?= -flto -Wl,--exclude-libs=ALL
 CXXFLAGS = $(LLVM_CXXFLAGS) $(CXX_FLTO_FLAGS)
 LDFLAGS = $(LLVM_LDFLAGS) $(LD_FLTO_FLAGS)
 LIBS = $(LLVM_LIBS)
+INCLUDE = core.h
 SRC = assembly.cpp bitcode.cpp core.cpp initfini.cpp module.cpp value.cpp \
 	  executionengine.cpp transforms.cpp passmanagers.cpp targets.cpp dylib.cpp \
 	  linker.cpp
@@ -15,7 +16,7 @@ OUTPUT = libllvmlite.so
 
 all: $(OUTPUT)
 
-$(OUTPUT): $(SRC)
+$(OUTPUT): $(SRC) $(INCLUDE)
 	# static-libstdc++ avoids runtime dependencies on a
 	# particular libstdc++ version.
 	$(CXX) -static-libstdc++ -shared $(CXXFLAGS) $(SRC) -o $(OUTPUT) $(LDFLAGS) $(LIBS)

{llvmlite-0.10.0 → llvmlite-0.12.0}/ffi/Makefile.osx

@@ -3,12 +3,13 @@ CXX = clang++ -std=c++11 -stdlib=libc++
 CXXFLAGS = $(LLVM_CXXFLAGS)
 LDFLAGS = $(LLVM_LDFLAGS)
 LIBS = $(LLVM_LIBS)
+INCLUDE = core.h
 SRC = assembly.cpp bitcode.cpp core.cpp initfini.cpp module.cpp value.cpp \
 	  executionengine.cpp transforms.cpp passmanagers.cpp targets.cpp dylib.cpp \
 	  linker.cpp
 OUTPUT = libllvmlite.dylib
 
-all: $(SRC)
+all: $(SRC) $(INCLUDE)
 	MACOSX_DEPLOYMENT_TARGET=10.7 $(CXX) -dynamiclib $(CXXFLAGS) $(SRC) -o $(OUTPUT) $(LDFLAGS) $(LIBS)
 
 clean:

{llvmlite-0.10.0 → llvmlite-0.12.0}/ffi/build.py

@@ -102,11 +102,22 @@ def main_posix(kind, library_ext):
     print("LLVM version... ", end='')
     sys.stdout.flush()
     try:
-        subprocess.check_call([llvm_config, '--version'])
+        out = subprocess.check_output([llvm_config, '--version'])
     except (OSError, subprocess.CalledProcessError):
         raise RuntimeError("%s failed executing, please point LLVM_CONFIG "
                            "to the path for llvm-config" % (llvm_config,))
 
+    out = out.decode('latin1')
+    print(out)
+    if not out.startswith('3.7.'):
+        msg = (
+            "Building llvmlite requires LLVM 3.7.x. Be sure to "
+            "set LLVM_CONFIG to the right executable path.\n"
+            "Read the documentation at http://llvmlite.pydata.org/ for more "
+            "information about building llvmlite.\n"
+            )
+        raise RuntimeError(msg)
+
     # Get LLVM information for building
     libs = run_llvm_config(llvm_config, "--system-libs --libs all".split())
     # Normalize whitespace (trim newlines)

{llvmlite-0.10.0 → llvmlite-0.12.0}/ffi/initfini.cpp

@@ -38,9 +38,10 @@ LLVMPY_Shutdown(){
 // NOTE: it is important that we don't export functions which we don't use,
 // especially those which may pull in large amounts of additional code or data.
 
-// INIT(AllTargetInfos)
-// INIT(AllTargets)
-// INIT(AllTargetMCs)
+INIT(AllTargetInfos)
+INIT(AllTargets)
+INIT(AllTargetMCs)
+INIT(AllAsmPrinters)
 INIT(NativeTarget)
 INIT(NativeAsmParser)
 INIT(NativeAsmPrinter)

llvmlite-0.12.0/ffi/passmanagers.cpp

@@ -0,0 +1,153 @@
+#include "core.h"
+#include "llvm-c/Transforms/Scalar.h"
+#include "llvm-c/Transforms/IPO.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/Transforms/Scalar.h"
+#include "llvm/Transforms/IPO.h"
+
+using namespace llvm;
+
+extern "C" {
+
+API_EXPORT(LLVMPassManagerRef)
+LLVMPY_CreatePassManager()
+{
+    return LLVMCreatePassManager();
+}
+
+API_EXPORT(void)
+LLVMPY_DisposePassManager(LLVMPassManagerRef PM)
+{
+    return LLVMDisposePassManager(PM);
+}
+
+
+API_EXPORT(LLVMPassManagerRef)
+LLVMPY_CreateFunctionPassManager(LLVMModuleRef M)
+{
+    return LLVMCreateFunctionPassManagerForModule(M);
+}
+
+API_EXPORT(int)
+LLVMPY_RunPassManager(LLVMPassManagerRef PM,
+                      LLVMModuleRef M)
+{
+    return LLVMRunPassManager(PM, M);
+}
+
+API_EXPORT(int)
+LLVMPY_RunFunctionPassManager(LLVMPassManagerRef PM,
+                              LLVMValueRef F)
+{
+    return LLVMRunFunctionPassManager(PM, F);
+}
+
+API_EXPORT(int)
+LLVMPY_InitializeFunctionPassManager(LLVMPassManagerRef FPM)
+{
+    return LLVMInitializeFunctionPassManager(FPM);
+}
+
+API_EXPORT(int)
+LLVMPY_FinalizeFunctionPassManager(LLVMPassManagerRef FPM)
+{
+    return LLVMFinalizeFunctionPassManager(FPM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddConstantMergePass(LLVMPassManagerRef PM)
+{
+    LLVMAddConstantMergePass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddDeadArgEliminationPass(LLVMPassManagerRef PM)
+{
+    LLVMAddDeadArgEliminationPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddFunctionAttrsPass(LLVMPassManagerRef PM)
+{
+    LLVMAddFunctionAttrsPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddFunctionInliningPass(LLVMPassManagerRef PM, int Threshold)
+{
+    unwrap(PM)->add(createFunctionInliningPass(Threshold));
+}
+
+API_EXPORT(void)
+LLVMPY_AddGlobalOptimizerPass(LLVMPassManagerRef PM)
+{
+    LLVMAddGlobalOptimizerPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddGlobalDCEPass(LLVMPassManagerRef PM)
+{
+    LLVMAddGlobalDCEPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddIPSCCPPass(LLVMPassManagerRef PM)
+{
+    LLVMAddIPSCCPPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddDeadCodeEliminationPass(LLVMPassManagerRef PM)
+{
+    unwrap(PM)->add(createDeadCodeEliminationPass());
+}
+
+API_EXPORT(void)
+LLVMPY_AddCFGSimplificationPass(LLVMPassManagerRef PM)
+{
+    LLVMAddCFGSimplificationPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddGVNPass(LLVMPassManagerRef PM)
+{
+    LLVMAddGVNPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddInstructionCombiningPass(LLVMPassManagerRef PM)
+{
+    LLVMAddInstructionCombiningPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddLICMPass(LLVMPassManagerRef PM)
+{
+    LLVMAddLICMPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddSCCPPass(LLVMPassManagerRef PM)
+{
+    LLVMAddSCCPPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddSROAPass(LLVMPassManagerRef PM)
+{
+    unwrap(PM)->add(createSROAPass());
+}
+
+API_EXPORT(void)
+LLVMPY_AddTypeBasedAliasAnalysisPass(LLVMPassManagerRef PM)
+{
+    LLVMAddTypeBasedAliasAnalysisPass(PM);
+}
+
+API_EXPORT(void)
+LLVMPY_AddBasicAliasAnalysisPass(LLVMPassManagerRef PM)
+{
+    LLVMAddBasicAliasAnalysisPass(PM);
+}
+
+} // end extern "C"

{llvmlite-0.10.0 → llvmlite-0.12.0}/ffi/targets.cpp

@@ -245,6 +245,11 @@ LLVMPY_GetTargetMachineTriple(LLVMTargetMachineRef TM, const char **Out)
     *Out = LLVMGetTargetMachineTriple(TM);
 }
 
+API_EXPORT(void)
+LLVMPY_SetTargetMachineAsmVerbosity(LLVMTargetMachineRef TM, int verbose)
+{
+    LLVMSetTargetMachineAsmVerbosity(TM, verbose);
+}
 
 API_EXPORT(LLVMMemoryBufferRef)
 LLVMPY_TargetMachineEmitToMemory (

{llvmlite-0.10.0 → llvmlite-0.12.0}/llvmlite/_version.py

@@ -4,8 +4,8 @@
 # unpacked source archive. Distribution tarballs contain a pre-generated copy
 # of this file.
 
-version_version = '0.10.0'
-version_full = 'f89752cb177ca0ccfe3e61c408daaf0ec20becd8'
+version_version = '0.12.0'
+version_full = '960b89612ab2bb1fc1f0041dfdc60d77fb540eaf'
 def get_versions(default={}, verbose=False):
     return {'version': version_version, 'full': version_full}
 

{llvmlite-0.10.0 → llvmlite-0.12.0}/llvmlite/binding/initfini.py

@@ -10,6 +10,24 @@ def initialize():
     ffi.lib.LLVMPY_InitializeCore()
 
 
+def initialize_all_targets():
+    """
+    Initialize all targets. Necessary before targets can be looked up
+    via the :class:`Target` class.
+    """
+    ffi.lib.LLVMPY_InitializeAllTargetInfos()
+    ffi.lib.LLVMPY_InitializeAllTargets()
+    ffi.lib.LLVMPY_InitializeAllTargetMCs()
+
+def initialize_all_asmprinters():
+    """
+    Initialize all code generators. Necessary before generating
+    any assembly or machine code via the :meth:`TargetMachine.emit_object`
+    and :meth:`TargetMachine.emit_assembly` methods.
+    """
+    ffi.lib.LLVMPY_InitializeAllAsmPrinters()
+
+
 def initialize_native_target():
     """
     Initialize the native (host) target.  Necessary before doing any

llvmlite-0.12.0/llvmlite/binding/passmanagers.py

@@ -0,0 +1,170 @@
+from __future__ import print_function, absolute_import
+from ctypes import c_bool, c_int
+from . import ffi
+
+
+def create_module_pass_manager():
+    return ModulePassManager()
+
+
+def create_function_pass_manager(module):
+    return FunctionPassManager(module)
+
+
+class PassManager(ffi.ObjectRef):
+    """PassManager
+    """
+
+    def _dispose(self):
+        self._capi.LLVMPY_DisposePassManager(self)
+
+    def add_constant_merge_pass(self):
+        """See http://llvm.org/docs/Passes.html#constmerge-merge-duplicate-global-constants."""
+        ffi.lib.LLVMPY_AddConstantMergePass(self)
+
+    def add_dead_arg_elimination_pass(self):
+        """See http://llvm.org/docs/Passes.html#deadargelim-dead-argument-elimination."""
+        ffi.lib.LLVMPY_AddDeadArgEliminationPass(self)
+
+    def add_function_attrs_pass(self):
+        """See http://llvm.org/docs/Passes.html#functionattrs-deduce-function-attributes."""
+        ffi.lib.LLVMPY_AddFunctionAttrsPass(self)
+
+    def add_function_inlining_pass(self, threshold):
+        """See http://llvm.org/docs/Passes.html#inline-function-integration-inlining."""
+        ffi.lib.LLVMPY_AddFunctionInliningPass(self, threshold)
+
+    def add_global_dce_pass(self):
+        """See http://llvm.org/docs/Passes.html#globaldce-dead-global-elimination."""
+        ffi.lib.LLVMPY_AddGlobalDCEPass(self)
+
+    def add_global_optimizer_pass(self):
+        """See http://llvm.org/docs/Passes.html#globalopt-global-variable-optimizer."""
+        ffi.lib.LLVMPY_AddGlobalOptimizerPass(self)
+
+    def add_ipsccp_pass(self):
+        """See http://llvm.org/docs/Passes.html#ipsccp-interprocedural-sparse-conditional-constant-propagation."""
+        ffi.lib.LLVMPY_AddIPSCCPPass(self)
+
+    def add_dead_code_elimination_pass(self):
+        """See http://llvm.org/docs/Passes.html#dce-dead-code-elimination."""
+        ffi.lib.LLVMPY_AddDeadCodeEliminationPass(self)
+
+    def add_cfg_simplification_pass(self):
+        """See http://llvm.org/docs/Passes.html#simplifycfg-simplify-the-cfg."""
+        ffi.lib.LLVMPY_AddCFGSimplificationPass(self)
+
+    def add_gvn_pass(self):
+        """See http://llvm.org/docs/Passes.html#gvn-global-value-numbering."""
+        ffi.lib.LLVMPY_AddGVNPass(self)
+
+    def add_instruction_combining_pass(self):
+        """See http://llvm.org/docs/Passes.html#passes-instcombine."""
+        ffi.lib.LLVMPY_AddInstructionCombiningPass(self)
+
+    def add_licm_pass(self):
+        """See http://llvm.org/docs/Passes.html#licm-loop-invariant-code-motion."""
+        ffi.lib.LLVMPY_AddLICMPass(self)
+
+    def add_sccp_pass(self):
+        """See http://llvm.org/docs/Passes.html#sccp-sparse-conditional-constant-propagation."""
+        ffi.lib.LLVMPY_AddSCCPPass(self)
+
+    def add_sroa_pass(self):
+        """See http://llvm.org/docs/Passes.html#scalarrepl-scalar-replacement-of-aggregates-dt.
+        Note that this pass corresponds to the ``opt -sroa`` command-line option,
+        despite the link above."""
+        ffi.lib.LLVMPY_AddSROAPass(self)
+
+    def add_type_based_alias_analysis_pass(self):
+        ffi.lib.LLVMPY_AddTypeBasedAliasAnalysisPass(self)
+
+    def add_basic_alias_analysis_pass(self):
+        """See http://llvm.org/docs/AliasAnalysis.html#the-basicaa-pass."""
+        ffi.lib.LLVMPY_AddBasicAliasAnalysisPass(self)
+
+
+class ModulePassManager(PassManager):
+
+    def __init__(self, ptr=None):
+        if ptr is None:
+            ptr = ffi.lib.LLVMPY_CreatePassManager()
+        PassManager.__init__(self, ptr)
+
+    def run(self, module):
+        """
+        Run optimization passes on the given module.
+        """
+        return ffi.lib.LLVMPY_RunPassManager(self, module)
+
+
+class FunctionPassManager(PassManager):
+
+    def __init__(self, module):
+        ptr = ffi.lib.LLVMPY_CreateFunctionPassManager(module)
+        self._module = module
+        module._owned = True
+        PassManager.__init__(self, ptr)
+
+    def initialize(self):
+        """
+        Initialize the FunctionPassManager.  Returns True if it produced
+        any changes (?).
+        """
+        return ffi.lib.LLVMPY_InitializeFunctionPassManager(self)
+
+    def finalize(self):
+        """
+        Finalize the FunctionPassManager.  Returns True if it produced
+        any changes (?).
+        """
+        return ffi.lib.LLVMPY_FinalizeFunctionPassManager(self)
+
+    def run(self, function):
+        """
+        Run optimization passes on the given function.
+        """
+        return ffi.lib.LLVMPY_RunFunctionPassManager(self, function)
+
+
+# ============================================================================
+# FFI
+
+ffi.lib.LLVMPY_CreatePassManager.restype = ffi.LLVMPassManagerRef
+
+ffi.lib.LLVMPY_CreateFunctionPassManager.argtypes = [ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_CreateFunctionPassManager.restype = ffi.LLVMPassManagerRef
+
+ffi.lib.LLVMPY_DisposePassManager.argtypes = [ffi.LLVMPassManagerRef]
+
+ffi.lib.LLVMPY_RunPassManager.argtypes = [ffi.LLVMPassManagerRef,
+                                          ffi.LLVMModuleRef]
+ffi.lib.LLVMPY_RunPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_InitializeFunctionPassManager.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_InitializeFunctionPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_FinalizeFunctionPassManager.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_FinalizeFunctionPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_RunFunctionPassManager.argtypes = [ffi.LLVMPassManagerRef,
+                                                  ffi.LLVMValueRef]
+ffi.lib.LLVMPY_RunFunctionPassManager.restype = c_bool
+
+ffi.lib.LLVMPY_AddConstantMergePass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddDeadArgEliminationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddFunctionAttrsPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddFunctionInliningPass.argtypes = [ffi.LLVMPassManagerRef, c_int]
+ffi.lib.LLVMPY_AddGlobalDCEPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddGlobalOptimizerPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddIPSCCPPass.argtypes = [ffi.LLVMPassManagerRef]
+
+ffi.lib.LLVMPY_AddDeadCodeEliminationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddCFGSimplificationPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddGVNPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddInstructionCombiningPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddLICMPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddSCCPPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddSROAPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddTypeBasedAliasAnalysisPass.argtypes = [ffi.LLVMPassManagerRef]
+ffi.lib.LLVMPY_AddBasicAliasAnalysisPass.argtypes = [ffi.LLVMPassManagerRef]

{llvmlite-0.10.0 → llvmlite-0.12.0}/llvmlite/binding/targets.py

@@ -246,6 +246,13 @@ class TargetMachine(ffi.ObjectRef):
         """
         ffi.lib.LLVMPY_AddAnalysisPasses(self, pm)
 
+    def set_asm_verbosity(self, verbose):
+        """
+        Set whether this target machine will emit assembly with human-readable
+        comments describing control flow, debug information, and so on.
+        """
+        ffi.lib.LLVMPY_SetTargetMachineAsmVerbosity(self, verbose)
+
     def emit_object(self, module):
         """
         Represent the module as a code object, suitable for use with
@@ -366,6 +373,9 @@ ffi.lib.LLVMPY_DisposeTargetMachine.argtypes = [ffi.LLVMTargetMachineRef]
 ffi.lib.LLVMPY_GetTargetMachineTriple.argtypes = [ffi.LLVMTargetMachineRef,
                                                   POINTER(c_char_p)]
 
+ffi.lib.LLVMPY_SetTargetMachineAsmVerbosity.argtypes = [ffi.LLVMTargetMachineRef,
+                                                        c_int]
+
 ffi.lib.LLVMPY_AddAnalysisPasses.argtypes = [
     ffi.LLVMTargetMachineRef,
     ffi.LLVMPassManagerRef,

{llvmlite-0.10.0 → llvmlite-0.12.0}/llvmlite/ir/_utils.py

@@ -53,3 +53,23 @@ class _StringReferenceCaching(object):
         except AttributeError:
             s = self.__cached_refstr = self._get_reference()
             return s
+
+
+class _HasMetadata(object):
+
+    def set_metadata(self, name, node):
+        """
+        Attach unnamed metadata *node* to the metadata slot *name* of this value.
+        """
+        self.metadata[name] = node
+
+    def _stringify_metadata(self, leading_comma=False):
+        if self.metadata:
+            buf = []
+            if leading_comma:
+                buf.append("")
+            buf += ["!{0} {1}".format(k, v.get_reference())
+                    for k, v in self.metadata.items()]
+            return ', '.join(buf)
+        else:
+            return ''

{llvmlite-0.10.0 → llvmlite-0.12.0}/llvmlite/ir/builder.py

@@ -472,7 +472,7 @@ class IRBuilder(object):
         """
         return self._icmp('u', cmpop, lhs, rhs, name)
 
-    def fcmp_ordered(self, cmpop, lhs, rhs, name=''):
+    def fcmp_ordered(self, cmpop, lhs, rhs, name='', flags=[]):
         """
         Floating-point ordered comparison:
             name = lhs <cmpop> rhs
@@ -483,11 +483,11 @@ class IRBuilder(object):
             op = 'o' + _CMP_MAP[cmpop]
         else:
             op = cmpop
-        instr = instructions.FCMPInstr(self.block, op, lhs, rhs, name=name)
+        instr = instructions.FCMPInstr(self.block, op, lhs, rhs, name=name, flags=flags)
         self._insert(instr)
         return instr
 
-    def fcmp_unordered(self, cmpop, lhs, rhs, name=''):
+    def fcmp_unordered(self, cmpop, lhs, rhs, name='', flags=[]):
         """
         Floating-point unordered comparison:
             name = lhs <cmpop> rhs
@@ -498,7 +498,7 @@ class IRBuilder(object):
             op = 'u' + _CMP_MAP[cmpop]
         else:
             op = cmpop
-        instr = instructions.FCMPInstr(self.block, op, lhs, rhs, name=name)
+        instr = instructions.FCMPInstr(self.block, op, lhs, rhs, name=name, flags=flags)
         self._insert(instr)
         return instr