Various updates.

* [PASS] Implement TargetLastWrittenRegisterPass, to write last written register.
* [FIX] Fix pylint formatting issues in various files.
* [FIX] Allow wider lines (up to 120 characters) in pylint.

Signed-off-by: Ramon Bertran Monfort <rbertra@us.ibm.com>

Author: rbertran

dev_tools/ci/code_conventions_001_pycodestyle.sh

@@ -32,7 +32,7 @@ python "$(command -v pycodestyle)" --version
 
 set +e
 # shellcheck disable=SC2046
-$NICE python "$(command -v pycodestyle)" --count --statistics $(find "$WORKSPACE/src/" "$WORKSPACE/targets/" -name "*.py") > "pycodestyle$PYTHON_VERSION.out" 2> "pycodestyle$PYTHON_VERSION.err"
+$NICE python "$(command -v pycodestyle)" --max-line-length=119 --count --statistics $(find "$WORKSPACE/src/" "$WORKSPACE/targets/" -name "*.py") > "pycodestyle$PYTHON_VERSION.out" 2> "pycodestyle$PYTHON_VERSION.err"
 error=$?
 set -e
 

src/microprobe/passes/float/__init__.py

@@ -46,9 +46,10 @@ def __init__(self, value=0):
         super().__init__()
 
         if callable(value):
-            ival = value 
+            ival = value
         else:
-            ival = lambda: value
+            def idem(x): return x
+            ival = idem
 
         self._var = microprobe.code.var.VariableSingle(
             "FP_INITVAL", "double", value=f"{ival():.20f}"

src/microprobe/passes/instruction/__init__.py

@@ -789,12 +789,12 @@ def __call__(self, building_block, target):
 
                 newins = []
 
-                for instr in self._instrs:
+                for instr, nops in zip(self._instrs, self._operands):
 
                     nins = target.new_instruction(instr.name)
 
-                    if self._operands is not None:
-                        nins.set_operands(self._operands)
+                    if nops is not None:
+                        nins.set_operands(nops)
 
                     newins.append(nins)
 

src/microprobe/passes/register/__init__.py

@@ -44,6 +44,7 @@
     "FixRegistersPass",
     "NoHazardsAllocationPass",
     "RandomAllocationPass",
+    "TargetLastWrittenRegisterPass",
 ]
 
 # Functions
@@ -70,6 +71,9 @@ def __init__(
         """
         super(DefaultRegisterAllocationPass, self).__init__()
         self._rand = rand
+        self._rand_imm = random.Random()
+        self._rand_imm.setstate(rand.getstate())
+
         self._min = minimize
         if self._min:
             raise NotImplementedError(
@@ -174,7 +178,7 @@ def __call__(self, building_block, target):
 
                         else:
                             operand.set_value(
-                                operand.type.random_value(self._rand)
+                                operand.type.random_value(self._rand_imm)
                             )
 
                     elif operand.type.address_relative:
@@ -896,7 +900,7 @@ def __call__(self, building_block, target):
 
         # Balance things: in case there are lots of inputs/outputs and few inputs or outputs.
         # Make sure we always have a minimum of 4 outputs and inputs
-        
+
         rtypes = set([reg.type for reg in inputoutputs + inputs + outputs])
         for rtype in rtypes:
             for cset in [inputs, outputs]:
@@ -913,10 +917,9 @@ def __call__(self, building_block, target):
                         if len(vset) == 0:
                             break
 
-                    cset.append(vset[0]) 
+                    cset.append(vset[0])
                     bset.remove(vset[0])
                     rcset = set([reg for reg in cset if reg.type == rtype])
-        
 
         LOG.debug("-" * 80)
         LOG.debug("BEFORE ALLOCATING 2")
@@ -926,12 +929,12 @@ def __call__(self, building_block, target):
         LOG.debug("Reserved %s", rregs)
         LOG.debug("-" * 80)
 
-        
         for s1, s2 in zip(
                 [inputs, inputoutputs, outputs, rregs],
                 [inputs, inputoutputs, outputs, rregs]):
 
-            if s1 == s2 : continue
+            if s1 == s2:
+                continue
             assert set(s1).isdisjoint(set(s2))
 
         if "MICROPROBEMAXREG" in os.environ:
@@ -1109,7 +1112,6 @@ def __call__(self, building_block, target):
                     LOG.debug("Operand set to: %s", regs[0])
                     operand.set_value(regs[0])
 
-
                     for value in operand.type.access(operand.value):
 
                         if value in inputoutputs:
@@ -1160,6 +1162,43 @@ def __call__(self, building_block, target):
                                 operand.unset_value()
 
 
+class TargetLastWrittenRegisterPass(microprobe.passes.Pass):
+    def __init__(self, rand: random.Random, set_inputs=False):
+        super(TargetLastWrittenRegisterPass, self).__init__()
+        self.description = "Set output operand of the current instruction to the last written register operand"
+        self._rand = rand
+        self._si = set_inputs
+
+    def __call__(self, building_block, target):
+
+        wreg = {}
+
+        for bbl in building_block.cfg.bbls:
+            for instr in bbl.instrs:
+                for operand in instr.operands():
+                    if not self._si:
+                        if not operand.is_output:
+                            continue
+
+                    if operand.type.immediate:
+                        continue
+                    regs = list(operand.type.values())
+                    rtype = regs[0].type
+                    if operand.value is not None and operand.is_output:
+                        wreg[rtype] = operand.value
+                    elif operand.value is None:
+                        if rtype not in wreg:
+                            operand.set_value(operand.type.random_value(self._rand))
+                            if operand.is_output:
+                                wreg[rtype] = operand.value
+                        elif wreg[rtype] not in operand.type.values():
+                            operand.set_value(operand.type.random_value(self._rand))
+                            if operand.is_output:
+                                wreg[rtype] = operand.value
+                        else:
+                            operand.set_value(wreg[rtype])
+
+
 class RandomAllocationPass(microprobe.passes.Pass):
     """RandomAllocationPass pass."""
 

src/microprobe/target/isa/operand.py

@@ -1062,11 +1062,10 @@ def random_value(self, rand: random.Random):
                     (val << 1) | (val >> (64 - 1))
                 ) & 0xFFFFFFFFFFFFFFFF
 
-
             valid = False
             count = 0
             nvalue = value
-            while not valid:  
+            while not valid:
                 try:
                     valid = self.check(nvalue)
                 except MicroprobeValueError:
@@ -1080,7 +1079,7 @@ def random_value(self, rand: random.Random):
             if not valid:
                 count = 0
                 nvalue = value
-                while not valid:  
+                while not valid:
                     try:
                         valid = self.check(nvalue)
                     except MicroprobeValueError: