def annotation(self, xdata: InstrXData) -> str:
        """data format: a:vvxxxxxx.

        vars[0]: lhslo
        vars[1]: lhshi
        xprs[0]: op1
        xprs[1]: op2
        xprs[2]: op1 div op2 (low, syntactic)
        xprs[3]: op1 div op2 (high, syntactic)
        xprs[4]: op1 div op2 (low, simplified)
        xprs[5]: op1 div op2 (high, syntactic)
        """

        lhslo = str(xdata.vars[0])
        lhshi = str(xdata.vars[1])
        resultlo = xdata.xprs[2]
        rresultlo = xdata.xprs[4]
        resulthi = xdata.xprs[3]
        rresulthi = xdata.xprs[5]
        xresultlo = simplify_result(xdata.args[4], xdata.args[6], resultlo,
                                    rresultlo)
        xresulthi = simplify_result(xdata.args[5], xdata.args[7], resulthi,
                                    rresulthi)
        pdiv = lhslo + ' := ' + xresultlo
        pmod = lhshi + ' := ' + xresulthi
        return pdiv + '; ' + pmod
Пример #2
0
    def annotation(self, xdata: InstrXData) -> str:
        """data format a:xxxx

        xprs[0]: rhs
        xprs[1]: condition (syntactic)
        xprs[2]: condition (simplified)
        xprs[3]: condition (negated)
        """

        result = xdata.xprs[1]
        rresult = xdata.xprs[2]
        xresult = simplify_result(xdata.args[1], xdata.args[2], result, rresult)
        return 'if ' + xresult + ' then goto ' + str(self.target)
Пример #3
0
    def annotation(self, xdata: InstrXData) -> str:
        """data format a:vxx

        vars[0]: lhs
        xprs[0]: rhs
        xprs[1]: rhs (simplified)
        """

        lhs = str(xdata.vars[0])
        rhs = xdata.xprs[0]
        rrhs = xdata.xprs[1]
        xrhs = simplify_result(xdata.args[1], xdata.args[2], rhs, rrhs)
        return lhs + ' := ' + xrhs
Пример #4
0
    def annotation(self, xdata: InstrXData) -> str:
        """data format a:vxxx

        vars[0]: lhs
        xprs[0]: rhs (rt)
        xprs[1]: rhs * 2^sa (syntactic)
        xprs[2]: rhs * 2^sa (simplified)
        """

        lhs = str(xdata.vars[0])
        result = xdata.xprs[1]
        rresult = xdata.xprs[2]
        xresult = simplify_result(xdata.args[2], xdata.args[3], result, rresult)
        return lhs + ' := ' + xresult
    def annotation(self, xdata: InstrXData) -> str:
        """data format: a:xxxx

        xprs[0]: rhs1
        xprs[1]: rhs2
        xprs[2]: rhs1 == rhs2 (syntactic)
        xprs[3]: rhs1 == rhs2 (simplified)
        """

        rhs1 = str(xdata.xprs[0])
        rhs2 = str(xdata.xprs[1])
        result = xdata.xprs[2]
        rresult = xdata.xprs[3]
        xresult = simplify_result(xdata.args[2], xdata.args[3], result, rresult)
        return 'trap if ' + rhs1 + ' == ' + rhs2 + ' (' + xresult + ')'
    def annotation(self, xdata: InstrXData) -> str:
        """data format a:xxxxx

        xprs[0]: rs value
        xprs[1]: rt value
        xprs[2]: result
        xprs[3]: result (simplified)
        xprs[4]: result (negated)
        """

        result = xdata.xprs[2]
        rresult = xdata.xprs[3]
        xresult = simplify_result(xdata.args[3], xdata.args[4], result,
                                  rresult)
        return "if " + xresult + " then goto " + str(self.target)
    def annotation(self, xdata: InstrXData) -> str:
        """data format a:vxxa

        vars[0]: lhs
        xprs[0]: rhs
        xprs[1]: rhs (simplified)
        xprs[2]: address of memory location
        """

        lhs = str(xdata.vars[0])
        rhs = xdata.xprs[0]
        rrhs = xdata.xprs[1]
        xrhs = simplify_result(xdata.args[1], xdata.args[2], rhs, rrhs)
        if lhs == '?' and len(xdata.xprs) == 3:
            lhs = derefstr(xdata.xprs[2])
        return lhs + ' := ' + xrhs
Пример #8
0
    def annotation(self, xdata: InstrXData) -> str:
        """xdata format: a:vxxxx .

        vars[0]: lhs (rd)
        xprs[0]: rhs1 (rs)
        xprs[1]: rhs2 (rt)
        xprs[2]: rhs1 + rhs2 (syntactic)
        xprs[3]: rhs1 + rhs2 (simplified)
        """

        lhs = str(xdata.vars[0])
        result = xdata.xprs[2]
        rresult = xdata.xprs[3]
        xresult = simplify_result(xdata.args[3], xdata.args[4], result,
                                  rresult)
        return lhs + ' := ' + xresult
    def annotation(self, xdata: InstrXData) -> str:
        """data format a:vxxxx

        vars[0]: lhs
        xprs[0]: rhs1 (rs)
        xprs[1]: rhs2 (immediate)
        xprs[2]: rhs1 < rhs2 (syntactic)
        xprs[3]: rhs1 < rhs2 (simplified)
        """

        lhs = str(xdata.vars[0])
        result = xdata.xprs[2]
        rresult = xdata.xprs[3]
        xresult = simplify_result(xdata.args[2], xdata.args[3], result,
                                  rresult)
        return lhs + ' := 1 if ' + xresult + ' else 0'
    def annotation(self, xdata: InstrXData) -> str:
        """data format a:vxxxx

        vars[0]: lhs
        xprs[0]: rhs
        xprs[1]: testxpr
        xprs[2]: condition (simplified)
        xprs[3]: rhs of lhs (alternative value)
        """

        lhs = str(xdata.vars[0])
        rhs = str(xdata.xprs[0])
        cond = xdata.xprs[1]
        ccond = xdata.xprs[2]
        xcond = simplify_result(xdata.args[2], xdata.args[3], cond, ccond)
        return 'if ' + xcond + ' then ' + lhs + ' := ' + rhs
    def annotation(self, xdata: InstrXData) -> str:
        """data format vvxxxx

        vars[0]: lhs-hi
        vars[1]: lhs-lo
        xprs[0]: rhs1 (rs)
        xprs[1]: rhs2 (rt)
        xprs[2]: rhs1 * rhs2 (syntactic)
        xprs[3]: rhs1 * rhs2 (simplified)
        """

        hi = str(xdata.vars[0])
        lo = str(xdata.vars[1])
        result = xdata.xprs[2]
        rresult = xdata.xprs[3]
        xresult = simplify_result(xdata.args[4], xdata.args[5], result,
                                  rresult)
        return '(' + hi + ',' + lo + ') := ' + xresult