[sw,otbnsim] Replace ignored subfunction by nops

This allows subfunctions to be replaced by NOPs for
constant time tests.

This is useful for the case where a function runs in
constant time under normal conditions but is not
necessarily constant time in case of FI.

Signed-off-by: Hakim Filali <[email protected]>

Author: h-filali

hw/ip/otbn/util/analyze_information_flow.py

@@ -53,7 +53,7 @@ def main() -> int:
             'Initially secret information-flow nodes. If provided, the final '
             'secrets will be printed.'))
     args = parser.parse_args()
-    program = decode_elf(args.elf)
+    program = decode_elf(args.elf, [])
 
     # Compute control-flow graph.
     if args.subroutine is None:

hw/ip/otbn/util/check_call_stack.py

@@ -51,7 +51,7 @@ def main() -> int:
     parser.add_argument('elf', help=('The .elf file to check.'))
     parser.add_argument('-v', '--verbose', action='store_true')
     args = parser.parse_args()
-    program = decode_elf(args.elf)
+    program = decode_elf(args.elf, [])
     result = check_call_stack(program)
     if args.verbose or result.has_errors() or result.has_warnings():
         print(result.report())

hw/ip/otbn/util/check_const_time.py

@@ -64,7 +64,7 @@ def main() -> int:
         constants = parse_required_constants(args.constants)
 
     # Compute control graph and get all nodes that influence control flow.
-    program = decode_elf(args.elf)
+    program = decode_elf(args.elf, args.ignore)
     if args.subroutine is None:
         graph = program_control_graph(program)
         to_analyze = 'entire program'

hw/ip/otbn/util/check_loop.py

@@ -224,7 +224,7 @@ def main() -> int:
     parser.add_argument('elf', help=('The .elf file to check.'))
     parser.add_argument('-v', '--verbose', action='store_true')
     args = parser.parse_args()
-    program = decode_elf(args.elf)
+    program = decode_elf(args.elf, [])
     result = check_loop(program)
     if args.verbose or result.has_errors() or result.has_warnings():
         print(result.report())

hw/ip/otbn/util/get_instruction_count_range.py

@@ -23,7 +23,7 @@ def main() -> int:
         help=('The specific subroutine to check. If not provided, the start '
               'point is _imem_start (whole program).'))
     args = parser.parse_args()
-    program = decode_elf(args.elf)
+    program = decode_elf(args.elf, [])
 
     # Compute instruction count range.
     if args.subroutine is None:

hw/ip/otbn/util/shared/decode.py

@@ -20,19 +20,57 @@
 
 class OTBNProgram:
     def __init__(self, symbols: Dict[str, int], insns: Dict[int, int],
-                 data: Dict[int, int]):
+                 data: Dict[int, int], nop_subfuncs: List[str]):
         self.symbols = symbols  # label -> PC
-        self.data = data  # addr -> data (32b word)
+        self.data = data        # addr -> data (32b word)
+
+        # Get start PCs for function symbols that we want to ignore
+        nop_starts = [symbols[name] for name in nop_subfuncs if name in symbols]
+        nop_ranges = []
+
+        # Build NOP ranges by scanning until JALR
+        for start_pc in nop_starts:
+            pc = start_pc
+            while pc in insns:
+                opcode = insns[pc]
+                mnem = INSNS_FILE.mnem_for_word(opcode)
+                if mnem is None:
+                    raise ValueError(f"Invalid instruction at PC {pc:#x}")
+                insn = INSNS_FILE.mnemonic_to_insn[mnem]
+
+                # Stop after at the JALR instruction
+                if mnem == "jalr":
+                    nop_ranges.append((start_pc, pc))
+                    break
+
+                pc += 4
+            else:
+                # In case we never find a ret
+                raise RuntimeError(
+                    f"Did not find 'JALR' for function starting at {start_pc:#x}"
+                )
 
         self.insns = {}
         for pc, opcode in insns.items():
-            mnem = INSNS_FILE.mnem_for_word(opcode)
-            if mnem is None:
-                raise ValueError(
-                    'No legal decoding for mnemonic: {}'.format(mnem))
-            insn = INSNS_FILE.mnemonic_to_insn[mnem]
-            assert insn.encoding is not None
-            enc_vals = insn.encoding.extract_operands(opcode)
+            # Check if PC lies within one of the NOP ranges
+            in_nop_region = any(
+                start <= pc < end for start, end in nop_ranges
+            )
+
+            if in_nop_region:
+                # Replace instruction that belong to a ignored routine with a NOP
+                insn = INSNS_FILE.mnemonic_to_insn["addi"]
+                enc_vals = {'imm': 0, 'grs1': 0, 'grd': 0}
+            else:
+                # Normal decode
+                mnem = INSNS_FILE.mnem_for_word(opcode)
+                if mnem is None:
+                    raise ValueError(
+                        'No legal decoding for mnemonic: {}'.format(mnem))
+                insn = INSNS_FILE.mnemonic_to_insn[mnem]
+                assert insn.encoding is not None
+                enc_vals = insn.encoding.extract_operands(opcode)
+
             op_vals = insn.enc_vals_to_op_vals(pc, enc_vals)
             self.insns[pc] = (insn, op_vals)
 
@@ -69,7 +107,7 @@ def _decode_mem(base_addr: int, data: bytes) -> Dict[int, int]:
             for offset, int_val in enumerate(struct.iter_unpack('<I', data))}
 
 
-def decode_elf(path: str) -> OTBNProgram:
+def decode_elf(path: str, nop_subfuncs: List[str]) -> OTBNProgram:
     '''Read ELF file at path and decode contents into an OTBNProgram instance
 
     Returns the OTBNProgram instance representing the program in the ELF file.
@@ -79,4 +117,4 @@ def decode_elf(path: str) -> OTBNProgram:
     insns = _decode_mem(0, imem_bytes)
     data = _decode_mem(0, dmem_bytes)
 
-    return OTBNProgram(symbols, insns, data)
+    return OTBNProgram(symbols, insns, data, nop_subfuncs)