pr-feedback: annotation fix & cleanups

Signed-off-by: Nathan Gauër <[email protected]>

Author: Keenuts

llvm/test/Other/spirv-sim/constant.spv

@@ -0,0 +1,36 @@
+; RUN: %if spirv-tools %{ spirv-as %s -o - | spirv-val - %}
+; RUN: spirv-sim --function=a --wave=1 --expects=2 -i %s
+; RUN: spirv-sim --function=b --wave=1 --expects=1 -i %s
+               OpCapability Shader
+               OpMemoryModel Logical GLSL450
+               OpEntryPoint GLCompute %main "main"
+               OpExecutionMode %main LocalSize 1 1 1
+               OpSource HLSL 670
+               OpName %a "a"
+               OpName %b "b"
+               OpName %main "main"
+        %int = OpTypeInt 32 1
+         %s1 = OpTypeStruct %int %int %int
+         %s2 = OpTypeStruct %s1
+      %int_1 = OpConstant %int 1
+      %int_2 = OpConstant %int 2
+     %s1_1_2 = OpConstantComposite %s1 %int_1 %int_2 %int_1
+      %s2_s1 = OpConstantComposite %s2 %s1_1_2
+       %void = OpTypeVoid
+  %main_type = OpTypeFunction %void
+   %simple_type = OpTypeFunction %int
+       %main = OpFunction %void None %main_type
+      %entry = OpLabel
+               OpReturn
+               OpFunctionEnd
+          %a = OpFunction %int None %simple_type
+          %1 = OpLabel
+          %2 = OpCompositeExtract %int %s1_1_2 1
+               OpReturnValue %2
+               OpFunctionEnd
+          %b = OpFunction %int None %simple_type
+          %3 = OpLabel
+          %4 = OpCompositeExtract %int %s2_s1 0 2
+               OpReturnValue %4
+               OpFunctionEnd
+

llvm/utils/spirv-sim/instructions.py

@@ -1,16 +1,16 @@
+from typing import Optional
+
 # Base class for an instruction. To implement a basic instruction that doesn't
 # impact the control-flow, create a new class inheriting from this.
 class Instruction:
-    _result: str
+    # Contains the name of the output register, if any.
+    _result: Optional[str]
+    # Contains the instruction opcode.
+    _opcode: str
+    # Contains all the instruction operands, except result and opcode.
+    _operands: list[str]
 
     def __init__(self, line: str):
-        # Contains the name of the output register, if any.
-        self._result: str = None
-        # Contains the instruction opcode.
-        self._opcode: str = None
-        # Contains all the instruction operands, except result and opcode.
-        self._operands: list[str] = []
-
         self.line = line
         tokens = line.split()
         if len(tokens) > 1 and tokens[1] == "=":
@@ -38,7 +38,7 @@ def operands(self) -> list[str]:
     # Returns the instruction output register. Calling this function is
     # only allowed if has_output_register() is true.
     def output_register(self) -> str:
-        assert self.has_output_register()
+        assert self._result is not None
         return self._result
 
     # Returns true if this function has an output register. False otherwise.
@@ -132,20 +132,11 @@ def static_execution(self, lane):
 class OpConstantComposite(OpConstant):
     def static_execution(self, lane):
         result = []
-        length = self.get_register(self._operands[0])
         for op in self._operands[1:]:
-            result.append(self.get_register(op))
+            result.append(lane.get_register(op))
         lane.set_register(self._result, result)
 
 
-class OpConstantComposite(OpConstant):
-    def static_execution(self, vm, state):
-        output = []
-        for op in self._operands[1:]:
-            output.append(state.get_register(op))
-        state.set_register(self._result, output)
-
-
 # Control flow instructions
 class OpFunctionCall(Instruction):
     def _impl(self, module, lane):
@@ -217,7 +208,7 @@ def _impl(self, module, lane):
 
 
 # Convergence instructions
-class _MergeInstruction(Instruction):
+class MergeInstruction(Instruction):
     def merge_location(self):
         return self._operands[0]
 
@@ -228,11 +219,11 @@ def _impl(self, module, lane):
         lane.handle_convergence_header(self)
 
 
-class OpLoopMerge(_MergeInstruction):
+class OpLoopMerge(MergeInstruction):
     pass
 
 
-class OpSelectionMerge(_MergeInstruction):
+class OpSelectionMerge(MergeInstruction):
     pass
 
 
@@ -265,6 +256,13 @@ def _impl(self, module, lane):
             output.append(lane.get_register(op))
         lane.set_register(self._result, output)
 
+class OpCompositeExtract(Instruction):
+    def _impl(self, module, lane):
+        value = lane.get_register(self._operands[1])
+        output = value
+        for op in self._operands[2:]:
+          output = output[int(op)]
+        lane.set_register(self._result, output)
 
 class OpStore(Instruction):
     def _impl(self, module, lane):
@@ -303,13 +301,6 @@ def _impl(self, module, lane):
         lane.set_register(self._result, not LHS)
 
 
-class OpSGreaterThan(Instruction):
-    def _impl(self, module, lane):
-        LHS = lane.get_register(self._operands[1])
-        RHS = lane.get_register(self._operands[2])
-        lane.set_register(self._result, LHS > RHS)
-
-
 class _LessThan(Instruction):
     def _impl(self, module, lane):
         LHS = lane.get_register(self._operands[1])