Esempio n. 1
0
 def genraisingop1(self, opname, gv_arg):
     ll_assert(self.rgenop.currently_writing is self,
               "genraisingop1: bad currently_writing")
     gv_res = LLVar(llimpl.genop(self.b, opname, [gv_arg], llimpl.guess))
     gv_exc = LLVar(
         llimpl.genop(self.b, "check_and_clear_exc", [], gv_Bool.v))
     return gv_res, gv_exc
Esempio n. 2
0
 def genraisingop1(self, opname, gv_arg):
     debug_assert(self.rgenop.currently_writing is self,
                  "genraisingop1: bad currently_writing")
     gv_res = LLVar(llimpl.genop(self.b, opname, [gv_arg], llimpl.guess))
     gv_exc = LLVar(llimpl.genop(self.b, "check_and_clear_exc", [],
                                 gv_Bool.v))
     return gv_res, gv_exc
Esempio n. 3
0
 def genop_ptr_ne(self, gv_PTRTYPE, gv_ptr1, gv_ptr2):
     ll_assert(self.rgenop.currently_writing is self,
               "genop_ptr_ne: bad currently_writing")
     gv_ptr1 = llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr1.v)
     gv_ptr2 = llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr2.v)
     return LLVar(
         llimpl.genop(self.b, 'ptr_ne', [gv_ptr1, gv_ptr2], gv_Bool.v))
Esempio n. 4
0
 def genop_ptr_ne(self, gv_PTRTYPE, gv_ptr1, gv_ptr2):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_ptr_ne: bad currently_writing")
     gv_ptr1 = llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr1.v)
     gv_ptr2 = llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr2.v)        
     return LLVar(llimpl.genop(self.b, 'ptr_ne', [gv_ptr1, gv_ptr2],
                               gv_Bool.v))
Esempio n. 5
0
 def alloc_frame_place(self, gv_TYPE, gv_initial_value=None):
     ll_assert(self.rgenop.currently_writing is self,
               "alloc_frame_place: bad currently_writing")
     if gv_initial_value is None:
         gv_initial_value = self.rgenop.genzeroconst(gv_TYPE)
     gv_initial_value = llimpl.cast(self.b, gv_TYPE.v, gv_initial_value.v)
     v = LLVar(
         llimpl.genop(self.b, 'same_as', [gv_initial_value], gv_TYPE.v))
     return LLPlace(v, llimpl.get_frame_info(self.b, [v]))
Esempio n. 6
0
 def alloc_frame_place(self, gv_TYPE, gv_initial_value=None):
     debug_assert(self.rgenop.currently_writing is self,
                  "alloc_frame_place: bad currently_writing")
     if gv_initial_value is None:
         gv_initial_value = self.rgenop.genzeroconst(gv_TYPE)
     gv_initial_value = llimpl.cast(self.b, gv_TYPE.v, gv_initial_value.v)
     v = LLVar(llimpl.genop(self.b, 'same_as', [gv_initial_value],
                            gv_TYPE.v))
     return LLPlace(v, llimpl.get_frame_info(self.b, [v]))
Esempio n. 7
0
 def genop_cast_int_to_ptr(self, gv_PTRTYPE, gv_int):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_cast_int_to_ptr: bad currently_writing")
     return LLVar(llimpl.genop(self.b, 'cast_int_to_ptr', [gv_int],
                               gv_PTRTYPE.v))
Esempio n. 8
0
 def genop_ptr_nonzero(self, gv_PTRTYPE, gv_ptr):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_ptr_nonzero: bad currently_writing")
     gv_ptr = llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr.v)
     return LLVar(llimpl.genop(self.b, 'ptr_nonzero', [gv_ptr], gv_Bool.v))
Esempio n. 9
0
        llimpl.gensetarrayitem(self.b, gv_ptr.v, gv_index.v, gv_value.v)
        #vars_gv = [gv_ptr.v, gv_index.v, gv_value.v]
        #llimpl.genop(self.b, 'setarrayitem', vars_gv, gv_Void.v)

    def genop_getarraysize(self, gv_ITEMTYPE, gv_ptr):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_getarraysize: bad currently_writing")
        return LLVar(llimpl.gengetarraysize(self.b, gv_ptr.v))
        #return LLVar(llimpl.genop(self.b, 'getarraysize', [gv_ptr.v],
        #                          gv_Signed.v))

    def genop_malloc_fixedsize(self, (gv_TYPE, gv_PTRTYPE)):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_malloc_fixedsize: bad currently_writing")
        vars_gv = [gv_TYPE.v, gv_flavor_gc.v]
        return LLVar(llimpl.genop(self.b, 'malloc', vars_gv, gv_PTRTYPE.v))

    def genop_malloc_varsize(self, (gv_TYPE, gv_PTRTYPE), gv_length):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_malloc_varsize: bad currently_writing")
        vars_gv = [gv_TYPE.v, gv_flavor_gc.v, gv_length.v]
        return LLVar(
            llimpl.genop(self.b, 'malloc_varsize', vars_gv, gv_PTRTYPE.v))

    def genop_same_as(self, gv_TYPE, gv_value):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_same_as: bad currently_writing")
        gv_value = llimpl.cast(self.b, gv_TYPE.v, gv_value.v)
        return LLVar(llimpl.genop(self.b, 'same_as', [gv_value], gv_TYPE.v))

    def genop_ptr_iszero(self, gv_PTRTYPE, gv_ptr):
Esempio n. 10
0
 def genop_getarraysize(self, gv_ITEMTYPE, gv_ptr):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_getarraysize: bad currently_writing")
     return LLVar(llimpl.genop(self.b, 'getarraysize', [gv_ptr.v],
                               gv_Signed.v))
Esempio n. 11
0
 def genop_same_as(self, gv_TYPE, gv_value):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_same_as: bad currently_writing")
     gv_value = llimpl.cast(self.b, gv_TYPE.v, gv_value.v)
     return LLVar(llimpl.genop(self.b, 'same_as', [gv_value], gv_TYPE.v))
Esempio n. 12
0
 def genop_getarraysubstruct(self, gv_ITEMTYPE, gv_ptr, gv_index):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_getarraysubstruct: bad currently_writing")
     vars_gv = [gv_ptr.v, gv_index.v]
     return LLVar(llimpl.genop(self.b, 'getarraysubstruct', vars_gv,
                               gv_ITEMTYPE.v))
Esempio n. 13
0
 def genop_setarrayitem(self, gv_ITEMTYPE, gv_ptr, gv_index, gv_value):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_setarrayitem: bad currently_writing")
     vars_gv = [gv_ptr.v, gv_index.v, gv_value.v]
     return LLVar(llimpl.genop(self.b, 'setarrayitem', vars_gv,
                               gv_Void.v))
Esempio n. 14
0
class LLBuilder(GenBuilder):
    jumped_from = None
    is_default_builder = False

    def __init__(self, rgenop, g, block):
        self.rgenop = rgenop
        self.gv_f = g
        self.b = block

    def end(self):
        ll_assert(self.rgenop.currently_writing is None,
                  "end: currently_writing")
        llimpl.end(self.gv_f)

    @specialize.arg(1)
    def genop1(self, opname, gv_arg):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop1: bad currently_writing")
        return LLVar(llimpl.genop(self.b, opname, [gv_arg], llimpl.guess))

    @specialize.arg(1)
    def genraisingop1(self, opname, gv_arg):
        ll_assert(self.rgenop.currently_writing is self,
                  "genraisingop1: bad currently_writing")
        gv_res = LLVar(llimpl.genop(self.b, opname, [gv_arg], llimpl.guess))
        gv_exc = LLVar(
            llimpl.genop(self.b, "check_and_clear_exc", [], gv_Bool.v))
        return gv_res, gv_exc

    @specialize.arg(1)
    def genop2(self, opname, gv_arg1, gv_arg2):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop2: bad currently_writing")
        return LLVar(
            llimpl.genop(self.b, opname, [gv_arg1, gv_arg2], llimpl.guess))

    @specialize.arg(1)
    def genraisingop2(self, opname, gv_arg1, gv_arg2):
        ll_assert(self.rgenop.currently_writing is self,
                  "genraisingop2: bad currently_writing")
        gv_res = LLVar(
            llimpl.genop(self.b, opname, [gv_arg1, gv_arg2], llimpl.guess))
        gv_exc = LLVar(
            llimpl.genop(self.b, "check_and_clear_exc", [], gv_Bool.v))
        return gv_res, gv_exc

    def genop_call(self, (ARGS_gv, gv_RESULT, _), gv_callable, args_gv):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_call: bad currently_writing")
        vars_gv = [gv_callable]
        j = 0
        for i in range(len(ARGS_gv)):
            if ARGS_gv[i] is gv_Void:
                gv_arg = gv_dummy_placeholder
            else:
                gv_arg = LLVar(llimpl.cast(self.b, ARGS_gv[i].v, args_gv[j].v))
                j += 1
            vars_gv.append(gv_arg)
        if gv_callable.is_const:
            v = llimpl.genop(self.b, 'direct_call', vars_gv, gv_RESULT.v)
        else:
            vars_gv.append(gv_dummy_placeholder)
            v = llimpl.genop(self.b, 'indirect_call', vars_gv, gv_RESULT.v)
        return LLVar(v)
Esempio n. 15
0
 def genop2(self, opname, gv_arg1, gv_arg2):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop2: bad currently_writing")
     return LLVar(llimpl.genop(self.b, opname, [gv_arg1, gv_arg2],
                               llimpl.guess))
Esempio n. 16
0
 def genop_get_frame_base(self):
     debug_assert(self.rgenop.currently_writing is self,
                  "genop_get_frame_base: bad currently_writing")
     return LLVar(llimpl.genop(self.b, 'get_frame_base', [],
                               gv_Address.v))
Esempio n. 17
0
 def genop1(self, opname, gv_arg):
     ll_assert(self.rgenop.currently_writing is self,
                  "genop1: bad currently_writing")
     return LLVar(llimpl.genop(self.b, opname, [gv_arg], llimpl.guess))
Esempio n. 18
0
 def genop_get_frame_base(self):
     ll_assert(self.rgenop.currently_writing is self,
               "genop_get_frame_base: bad currently_writing")
     return LLVar(llimpl.genop(self.b, 'get_frame_base', [], gv_Address.v))
Esempio n. 19
0
 def genop_cast_int_to_ptr(self, gv_PTRTYPE, gv_int):
     ll_assert(self.rgenop.currently_writing is self,
               "genop_cast_int_to_ptr: bad currently_writing")
     return LLVar(
         llimpl.genop(self.b, 'cast_int_to_ptr', [gv_int], gv_PTRTYPE.v))
Esempio n. 20
0
 def genop2(self, opname, gv_arg1, gv_arg2):
     ll_assert(self.rgenop.currently_writing is self,
               "genop2: bad currently_writing")
     return LLVar(
         llimpl.genop(self.b, opname, [gv_arg1, gv_arg2], llimpl.guess))
Esempio n. 21
0
 def genop_ptr_nonzero(self, gv_PTRTYPE, gv_ptr):
     ll_assert(self.rgenop.currently_writing is self,
               "genop_ptr_nonzero: bad currently_writing")
     gv_ptr = llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr.v)
     return LLVar(llimpl.genop(self.b, 'ptr_nonzero', [gv_ptr], gv_Bool.v))
Esempio n. 22
0
 def genop_same_as(self, gv_TYPE, gv_value):
     ll_assert(self.rgenop.currently_writing is self,
               "genop_same_as: bad currently_writing")
     gv_value = llimpl.cast(self.b, gv_TYPE.v, gv_value.v)
     return LLVar(llimpl.genop(self.b, 'same_as', [gv_value], gv_TYPE.v))
Esempio n. 23
0
            else:
                gv_arg = LLVar(llimpl.cast(self.b, ARGS_gv[i].v, args_gv[j].v))
                j += 1
            vars_gv.append(gv_arg)
        if gv_callable.is_const:
            v = llimpl.genop(self.b, 'direct_call', vars_gv, gv_RESULT.v)
        else:
            vars_gv.append(gv_dummy_placeholder)
            v = llimpl.genop(self.b, 'indirect_call', vars_gv, gv_RESULT.v)
        return LLVar(v)

    def genop_getfield(self, (gv_name, gv_PTRTYPE, gv_FIELDTYPE), gv_ptr):
        debug_assert(self.rgenop.currently_writing is self,
                     "genop_getfield: bad currently_writing")
        vars_gv = [llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr.v), gv_name.v]
        return LLVar(llimpl.genop(self.b, 'getfield', vars_gv,
                                  gv_FIELDTYPE.v))        
    
    def genop_setfield(self, (gv_name, gv_PTRTYPE, gv_FIELDTYPE), gv_ptr,
                                                                  gv_value):
        debug_assert(self.rgenop.currently_writing is self,
                     "genop_setfield: bad currently_writing")
        vars_gv = [llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr.v),
                   gv_name.v,
                   llimpl.cast(self.b, gv_FIELDTYPE.v, gv_value.v)]
        return LLVar(llimpl.genop(self.b, 'setfield', vars_gv,
                                  gv_Void.v))        
    
    def genop_getsubstruct(self, (gv_name, gv_PTRTYPE, gv_FIELDTYPE), gv_ptr):
        debug_assert(self.rgenop.currently_writing is self,
                     "genop_getsubstruct: bad currently_writing")
        vars_gv = [llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr.v), gv_name.v]
Esempio n. 24
0
        llimpl.gensetarrayitem(self.b, gv_ptr.v, gv_index.v, gv_value.v)
        #vars_gv = [gv_ptr.v, gv_index.v, gv_value.v]
        #llimpl.genop(self.b, 'setarrayitem', vars_gv, gv_Void.v)

    def genop_getarraysize(self, gv_ITEMTYPE, gv_ptr):
        ll_assert(self.rgenop.currently_writing is self,
                     "genop_getarraysize: bad currently_writing")
        return LLVar(llimpl.gengetarraysize(self.b, gv_ptr.v))
        #return LLVar(llimpl.genop(self.b, 'getarraysize', [gv_ptr.v],
        #                          gv_Signed.v))

    def genop_malloc_fixedsize(self, (gv_TYPE, gv_PTRTYPE)):
        ll_assert(self.rgenop.currently_writing is self,
                     "genop_malloc_fixedsize: bad currently_writing")
        vars_gv = [gv_TYPE.v, gv_flavor_gc.v]
        return LLVar(llimpl.genop(self.b, 'malloc', vars_gv,
                                  gv_PTRTYPE.v))

    def genop_malloc_varsize(self, (gv_TYPE, gv_PTRTYPE), gv_length):
        ll_assert(self.rgenop.currently_writing is self,
                     "genop_malloc_varsize: bad currently_writing")
        vars_gv = [gv_TYPE.v, gv_flavor_gc.v, gv_length.v]
        return LLVar(llimpl.genop(self.b, 'malloc_varsize', vars_gv,
                                  gv_PTRTYPE.v))

    def genop_same_as(self, gv_TYPE, gv_value):
        ll_assert(self.rgenop.currently_writing is self,
                     "genop_same_as: bad currently_writing")
        gv_value = llimpl.cast(self.b, gv_TYPE.v, gv_value.v)
        return LLVar(llimpl.genop(self.b, 'same_as', [gv_value], gv_TYPE.v))

    def genop_ptr_iszero(self, gv_PTRTYPE, gv_ptr):