oppc/pseudocode: always use keywords for emit calls

[openpower-isa.git] / src / openpower / oppc / pc_code.py

diff --git a/src/openpower/oppc/pc_code.py b/src/openpower/oppc/pc_code.py
index 1b66a1ca1e027505faaedf1382ffd09441907ead..62063a1fb0452691363938113da14c5fd30b3938 100644 (file)
--- a/src/openpower/oppc/pc_code.py
+++ b/src/openpower/oppc/pc_code.py
@@ -14,7 +14,7 @@ class Transient(pc_ast.Node):
         return super().__init__()
 
     def __str__(self):
-        return f"oppc_transient(&(struct oppc_int){{}}, {self.__value}, {self.__bits})"
+        return f"oppc_transient(&(struct oppc_value){{}}, {self.__value}, {self.__bits})"
 
 
 class CCall(pc_ast.Dataclass):
@@ -40,7 +40,7 @@ class CodeVisitor(pc_util.Visitor):
         self.__code[self.__header].emit(stmt=f"oppc_{name}(void) {{")
         with self.__code[self.__header]:
             for decl in self.__decls:
-                self.__code[self.__header].emit(stmt=f"struct oppc_int {decl};")
+                self.__code[self.__header].emit(stmt=f"struct oppc_value {decl};")
         self.__code[self.__footer].emit(stmt=f"}}")
 
     def __iter__(self):
@@ -51,10 +51,11 @@ class CodeVisitor(pc_util.Visitor):
     def __getitem__(self, node):
         return self.__code[node]
 
-    def transient(self, node, value="UINT64_C(0)", bits="(uint8_t)OPPC_XLEN"):
+    def transient(self, node,
+            value="UINT64_C(0)",
+            bits="(uint8_t)OPPC_XLEN"):
         transient = Transient(value=value, bits=bits)
-        with self.pseudocode(node=node):
-            self.traverse(root=transient)
+        self.traverse(root=transient)
         return transient
 
     def ccall(self, node, name, code, stmt=False):
@@ -71,10 +72,23 @@ class CodeVisitor(pc_util.Visitor):
 
         code = tuple(map(validate, code))
         ccall = CCall(name=name, code=code, stmt=stmt)
-        with self.pseudocode(node=node):
-            self.traverse(root=ccall)
+        self.traverse(root=ccall)
         return ccall
 
+    def ternary(self, node):
+        self[node].clear()
+        self[node].emit(stmt="(")
+        with self[node]:
+            for (level, stmt) in self[node.test]:
+                self[node].emit(stmt=stmt, level=level)
+            self[node].emit(stmt="?")
+            for (level, stmt) in self[node.body]:
+                self[node].emit(stmt=stmt, level=level)
+            self[node].emit(stmt=":")
+            for (level, stmt) in self[node.orelse]:
+                self[node].emit(stmt=stmt, level=level)
+        self[node].emit(stmt=")")
+
     @contextlib.contextmanager
     def pseudocode(self, node):
         for (level, stmt) in self.__pseudocode[node]:
@@ -97,36 +111,30 @@ class CodeVisitor(pc_util.Visitor):
         if isinstance(node.rvalue, (pc_ast.GPR, pc_ast.FPR)):
             self.__regfetch[str(node.rvalue)].append(node.rvalue)
 
-        rvalue = self[node.rvalue]
         if isinstance(node.rvalue, pc_ast.IfExpr):
-            rvalue = [(0, " ".join([
-                str(self[node.rvalue.test]),
-                "?",
-                str(self[node.rvalue.body[0]]),
-                ":",
-                str(self[node.rvalue.orelse[0]]),
-            ]))]
+            self.ternary(node=node.rvalue)
 
         if isinstance(node.lvalue, pc_ast.SubscriptExpr):
             ccall = self.ccall(name="oppc_subscript_assign", node=node, stmt=True, code=[
                 self[node.lvalue.subject],
                 self[node.lvalue.index],
-                rvalue,
+                self[node.rvalue],
             ])
         elif isinstance(node.lvalue, pc_ast.RangeSubscriptExpr):
             ccall = self.ccall(name="oppc_range_subscript_assign", node=node, stmt=True, code=[
                 self[node.lvalue.subject],
                 self[node.lvalue.start],
                 self[node.lvalue.end],
-                rvalue,
+                self[node.rvalue],
             ])
         else:
             ccall = self.ccall(name="oppc_assign", stmt=True, node=node, code=[
                 self[node.lvalue],
-                rvalue,
+                self[node.rvalue],
             ])
-        for (level, stmt) in self[ccall]:
-            self[node].emit(stmt=stmt, level=level)
+        with self.pseudocode(node=node):
+            for (level, stmt) in self[ccall]:
+                self[node].emit(stmt=stmt, level=level)
 
     @pc_util.Hook(pc_ast.BinaryExpr)
     def BinaryExpr(self, node):
@@ -140,7 +148,13 @@ class CodeVisitor(pc_util.Visitor):
             pc_ast.Lt, pc_ast.Le,
             pc_ast.Eq, pc_ast.NotEq,
             pc_ast.Ge, pc_ast.Gt,
+            pc_ast.LtU, pc_ast.GtU,
         )
+        if isinstance(node.left, pc_ast.IfExpr):
+            self.ternary(node=node.left)
+        if isinstance(node.right, pc_ast.IfExpr):
+            self.ternary(node=node.right)
+
         if isinstance(node.op, comparison):
             ccall = self.ccall(name=str(self[node.op]), node=node, code=[
                 self[node.left],
@@ -153,17 +167,21 @@ class CodeVisitor(pc_util.Visitor):
                 self[node.left],
                 self[node.right],
             ])
-        for (level, stmt) in self[ccall]:
-            self[node].emit(stmt=stmt, level=level)
+        with self.pseudocode(node=node):
+            for (level, stmt) in self[ccall]:
+                self[node].emit(stmt=stmt, level=level)
 
     @pc_util.Hook(pc_ast.UnaryExpr)
     def UnaryExpr(self, node):
         yield node
+        if isinstance(node.value, pc_ast.IfExpr):
+            self.ternary(node=node.value)
         ccall = self.ccall(name=str(self[node.op]), node=node, code=[
             self[node.value],
         ])
-        for (level, stmt) in self[ccall]:
-            self[node].emit(stmt=stmt, level=level)
+        with self.pseudocode(node=node):
+            for (level, stmt) in self[ccall]:
+                self[node].emit(stmt=stmt, level=level)
 
     @pc_util.Hook(
             pc_ast.Not, pc_ast.Add, pc_ast.Sub,
@@ -171,8 +189,10 @@ class CodeVisitor(pc_util.Visitor):
             pc_ast.Lt, pc_ast.Le,
             pc_ast.Eq, pc_ast.NotEq,
             pc_ast.Ge, pc_ast.Gt,
+            pc_ast.LtU, pc_ast.GtU,
             pc_ast.LShift, pc_ast.RShift,
             pc_ast.BitAnd, pc_ast.BitOr, pc_ast.BitXor,
+            pc_ast.BitConcat,
         )
     def Op(self, node):
         yield node
@@ -186,6 +206,8 @@ class CodeVisitor(pc_util.Visitor):
             pc_ast.Lt: "oppc_lt",
             pc_ast.Le: "oppc_le",
             pc_ast.Eq: "oppc_eq",
+            pc_ast.LtU: "oppc_ltu",
+            pc_ast.GtU: "oppc_gtu",
             pc_ast.NotEq: "oppc_noteq",
             pc_ast.Ge: "oppc_ge",
             pc_ast.Gt: "oppc_gt",
@@ -194,6 +216,7 @@ class CodeVisitor(pc_util.Visitor):
             pc_ast.BitAnd: "oppc_and",
             pc_ast.BitOr: "oppc_or",
             pc_ast.BitXor: "oppc_xor",
+            pc_ast.BitConcat: "oppc_concat",
         }[node.__class__]
         self[node].emit(stmt=op)
 
@@ -216,8 +239,9 @@ class CodeVisitor(pc_util.Visitor):
             raise NotImplementedError()
         value = f"UINT64_C({fmt(value)})"
         transient = self.transient(node=node, value=value, bits=bits)
-        for (level, stmt) in self[transient]:
-            self[node].emit(stmt=stmt, level=level)
+        with self.pseudocode(node=node):
+            for (level, stmt) in self[transient]:
+                self[node].emit(stmt=stmt, level=level)
 
     @pc_util.Hook(Transient)
     def Transient(self, node):
@@ -276,8 +300,9 @@ class CodeVisitor(pc_util.Visitor):
         yield node
         (value, bits) = ("OPPC_XLEN", "(uint8_t)OPPC_XLEN")
         transient = self.transient(node=node, value=value, bits=bits)
-        for (level, stmt) in self[transient]:
-            self[node].emit(stmt=stmt, level=level)
+        with self.pseudocode(node=node):
+            for (level, stmt) in self[transient]:
+                self[node].emit(stmt=stmt, level=level)
 
     @pc_util.Hook(pc_ast.SubscriptExpr)
     def SubscriptExpr(self, node):
@@ -403,7 +428,8 @@ class CodeVisitor(pc_util.Visitor):
     def Symbol(self, node):
         yield node
         self.__decls[str(node)].append(node)
-        self[node].emit(stmt=f"&{str(node)}")
+        with self.pseudocode(node=node):
+            self[node].emit(stmt=f"&{str(node)}")
 
     @pc_util.Hook(pc_ast.Node)
     def Node(self, node):