jit/backend/x86/test/test_ztranslation_basic.py::TestTranslationX86::()::test_stuff_translates

self = <rpython.jit.backend.x86.test.test_ztranslation_basic.TestTranslationX86 object at 0x0000026439371440>

    def test_stuff_translates(self):
        # this is a basic test that tries to hit a number of features and their
        # translation:
        # - jitting of loops and bridges
        # - two virtualizable types
        # - set_param interface
        # - profiler
        # - full optimizer
        # - floats neg and abs
        # - cast_int_to_float
        # - llexternal with macro=True
        # - extra place for the zero after STR instances
    
        class BasicFrame(object):
            _virtualizable_ = ['i']
    
            def __init__(self, i):
                self.i = i
    
        class Frame(BasicFrame):
            pass
    
        eci = ExternalCompilationInfo(post_include_bits=['''
    #define pypy_my_fabs(x)  fabs(x)
    '''], includes=['math.h'])
        myabs1 = rffi.llexternal('pypy_my_fabs', [lltype.Float],
                                 lltype.Float, macro=True, releasegil=False,
                                 compilation_info=eci)
        myabs2 = rffi.llexternal('pypy_my_fabs', [lltype.Float],
                                 lltype.Float, macro=True, releasegil=True,
                                 compilation_info=eci)
    
        @jl.returns(jl.MP_FILENAME,
                    jl.MP_LINENO,
                    jl.MP_INDEX)
        def get_location():
            return ("/home.py",0,0)
    
        jitdriver = JitDriver(greens = [],
                              reds = ['total', 'frame', 'prev_s', 'j'],
                              virtualizables = ['frame'],
                              get_location = get_location)
        def f(i, j):
            for param, _ in unroll_parameters:
                defl = PARAMETERS[param]
                set_param(jitdriver, param, defl)
            set_param(jitdriver, "threshold", 3)
            set_param(jitdriver, "trace_eagerness", 2)
            total = 0
            frame = Frame(i)
            j = float(j)
            prev_s = rstr.mallocstr(16)
            while frame.i > 3:
                jitdriver.can_enter_jit(frame=frame, total=total, j=j,
                                        prev_s=prev_s)
                jitdriver.jit_merge_point(frame=frame, total=total, j=j,
                                          prev_s=prev_s)
                _get_virtualizable_token(frame)
                total += frame.i
                if frame.i >= 20:
                    frame.i -= 2
                frame.i -= 1
                j *= -0.712
                if j + (-j):    raise ValueError
                j += frame.i
                k = myabs1(myabs2(j))
                if k - abs(j):  raise ValueError
                if k - abs(-j): raise ValueError
                s = rstr.mallocstr(16)
                rgc.ll_write_final_null_char(s)
                rgc.ll_write_final_null_char(prev_s)
                if (frame.i & 3) == 0:
                    prev_s = s
            return chr(total % 253)
        #
        class Virt2(object):
            _virtualizable_ = ['i']
            def __init__(self, i):
                self.i = i
        from rpython.rlib.libffi import types, CDLL, ArgChain
        from rpython.rlib.test.test_clibffi import get_libm_name
        libm_name = get_libm_name(sys.platform)
        jitdriver2 = JitDriver(greens=[], reds = ['v2', 'func', 'res', 'x'],
                               virtualizables = ['v2'])
        def libffi_stuff(i, j):
            lib = CDLL(libm_name)
            func = lib.getpointer('fabs', [types.double], types.double)
            res = 0.0
            x = float(j)
            v2 = Virt2(i)
            while v2.i > 0:
                jitdriver2.jit_merge_point(v2=v2, res=res, func=func, x=x)
                promote(func)
                argchain = ArgChain()
                argchain.arg(x)
                res = func.call(argchain, rffi.DOUBLE)
                v2.i -= 1
            return res
        #
        def main(i, j):
            a_char = f(i, j)
            a_float = libffi_stuff(i, j)
            return ord(a_char) * 10 + int(a_float)
>       expected = main(40, -49)

jit\backend\llsupport\test\ztranslation_test.py:126: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
jit\backend\llsupport\test\ztranslation_test.py:124: in main
    a_float = libffi_stuff(i, j)
jit\backend\llsupport\test\ztranslation_test.py:108: in libffi_stuff
    lib = CDLL(libm_name)
rlib\libffi.py:446: in __init__
    self.lib = dlopen(libname, mode)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _

name = 'msvcrt.dll', mode = -1

    def dlopen(name, mode=-1):
        # mode is unused on windows, but a consistant signature
        if not name:
            raise DLOpenError("cannot use None")
        with rffi.scoped_utf82wcharp(name, codepoints_in_utf8(name)) as buf:
            res = rwin32.LoadLibraryW(buf)
        if not res:
            err = rwin32.GetLastError_saved()
            ustr, lgt = rwin32.FormatErrorW(err)
>           raise DLOpenError(ustr)
E           DLOpenError: 'Teseiidmdl ol o efud\xf2\xa0\x80\x8d\x00\xeb\xb5\xb5\xe1\xb0\x80\xef\xbf\xbf\xef\xbf\xbf\x00\x00\xe6\x88\x80\xc9\xa4\xe1\x80\x80'

rlib\rdynload.py:242: DLOpenError
 (somefailed=True in jit/backend/x86/test/test_ztranslation_basic.py)

builder: rpython-win-x86-64 build #399

test: jit/backend/x86/test/test_ztranslation_basic/py/TestTranslationX86/()/test_stuff_translates