Esempio n. 1
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. 2
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. 3
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. 4
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. 5
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. 6
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. 7
0
                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)

    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,
Esempio n. 8
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. 9
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. 10
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. 11
0
        return LLVar(v)

    def genop_getfield(self, (gv_name, gv_PTRTYPE, gv_FIELDTYPE), gv_ptr):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_getfield: bad currently_writing")
        return LLVar(
            llimpl.gengetfield(self.b, gv_ptr.v, gv_PTRTYPE.v, gv_name.v))
        #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):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_setfield: bad currently_writing")
        v_value = llimpl.cast(self.b, gv_FIELDTYPE.v, gv_value.v)
        llimpl.gensetfield(self.b, gv_ptr.v, gv_PTRTYPE.v, gv_name.v, v_value)
        #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):
        ll_assert(self.rgenop.currently_writing is self,
                  "genop_getsubstruct: bad currently_writing")
        return LLVar(
            llimpl.gengetsubstruct(self.b, gv_ptr.v, gv_PTRTYPE.v, gv_name.v))
        #vars_gv = [llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr.v), gv_name.v]
        #return LLVar(llimpl.genop(self.b, 'getsubstruct', vars_gv,
        #                          gv_FIELDTYPE.v))
Esempio n. 12
0
        return LLVar(v)

    def genop_getfield(self, (gv_name, gv_PTRTYPE, gv_FIELDTYPE), gv_ptr):
        ll_assert(self.rgenop.currently_writing is self,
                     "genop_getfield: bad currently_writing")
        return LLVar(llimpl.gengetfield(self.b, gv_ptr.v,
                                        gv_PTRTYPE.v, gv_name.v))
        #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):
        ll_assert(self.rgenop.currently_writing is self,
                     "genop_setfield: bad currently_writing")
        v_value = llimpl.cast(self.b, gv_FIELDTYPE.v, gv_value.v)
        llimpl.gensetfield(self.b, gv_ptr.v, gv_PTRTYPE.v, gv_name.v, v_value)
        #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):
        ll_assert(self.rgenop.currently_writing is self,
                     "genop_getsubstruct: bad currently_writing")
        return LLVar(llimpl.gengetsubstruct(self.b, gv_ptr.v,
                                            gv_PTRTYPE.v, gv_name.v))
        #vars_gv = [llimpl.cast(self.b, gv_PTRTYPE.v, gv_ptr.v), gv_name.v]
        #return LLVar(llimpl.genop(self.b, 'getsubstruct', vars_gv,
        #                          gv_FIELDTYPE.v))