~manxi-david/pyeffect/pyeffect

# Copyright (C) 2011 David Manzanares <manxi.david@gmail.com>

#This file is part of PyEffect.

#

# PyEffect is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# PyEffect is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with PyEffect. If not, see <http://www.gnu.org/licenses/>.

 

#This is the matcher for the Stage 3

 

from s3 import act

from s3 import tImm

from s3 import tNat

from s3 import tChr

from s3 import loc

from s3 import lns

import arch

from arch import ins

 

nms = []

locs = []

 

class nm:

        def __init__(self, oldAct, newAct):

                if oldAct.loc.Type == "reg" and newAct.loc.Type == "reg" and oldAct.loc.index == newAct.loc.index:

                        pass

                else:

                        self.n = nms.__len__()

                        self.newAct = newAct

                        self.oldAct = oldAct

                        self.interferences = None

                        locs.append(oldAct.loc)

                        nms.append(self)

        def match(self):

                lns.now = lns.new()

                lns.now.exe = True

                var = self.newAct.up

                if var.Type == "char" and var.up.Type == "string":

                        lns.now.a1 = var.newAct("read", self.oldAct.loc)

                        lns.now.a1.pointer = True

                        lns.now.a2 = var.newAct("write", self.newAct.loc)

 

                else:

                        lns.now.a1 = var.newAct("read", self.oldAct.loc)

                        lns.now.a2 = var.newAct("write", self.newAct.loc)

                        if self.newAct.pointer == True:

                                lns.now.a1.pointer = True

                size = max(self.oldAct.size, self.newAct.up)

                if size == -1:

                        size = arch.wordSize

                lns.now.ins = "mov" + ins.suffixDic[size]

                #This makes the match just after the oldAct:

                #if self.oldAct.isNone==False:

                #       lns.now.insert(lns.lines.index(self.oldAct.line)+1)

                #else:

                #       lns.now.insert(self.newAct.line)

                lns.now.flow = self.newAct.line.flow

                lns.now.insert(self.newAct.line)

                locs.remove(self.oldAct.loc)

                self.interferences = -1

        def comp(self):

                if self.interferences != -1:

                        c = 0

                        for l in locs:

                                if l == self.newAct.loc and self.newAct.loc.asm != None:

                                        c = c + 1

                        self.interferences = c

        def __str__(self):

                return "NM " + str(self.n) + " Interferences: " + str(self.interferences) + "\nOld: " + str(self.oldAct) + "\nNew: " + str(self.newAct) + "\n"

 

def comp():

        lns.by.append("Match")

        #IMMS

        for v in tImm.imms:

                v.acts.sort()

                default = act.newNone(loc.new(None, None))

                for a in v.acts:

                        if a.loc != default.loc:

                                nm(default, a)

        #NATS

        for v in tNat.nats:

                v.acts.sort()

                la = act.newNone(loc.new(None))

                for a in v.acts:

                        if a.loc != la.loc and a.Type == "read" or a.Type == "modify":

                                nm(la, a)

                        if a.Type == "write" or a.Type == "modify":

                                la = a

        #exit(0)

        #CHARS

        for v in tChr.chrs:

                v.acts.sort()

                la = act.newNone(loc.new(None,))

                for a in v.acts:

                        if a.loc != la.loc and a.Type == "read":

                                nm(la, a)

        #Match

        m = nms.__len__()

        while m > 0:

                for x in nms:

                        x.comp()

                for x in nms:

                        if x.interferences == 0:

                                x.match()

                                m = m - 1

        lns.by.remove("Match")