diff --git a/nmigen/back/pysim.py b/nmigen/back/pysim.py
index 6f905ff..1cb44d4 100644
--- a/nmigen/back/pysim.py
+++ b/nmigen/back/pysim.py
@@ -1,3 +1,5 @@
+import sys
+import ast
 import inspect
 import warnings
 from contextlib import contextmanager
@@ -337,6 +339,28 @@ class _Emitter:
         return name
 
 
+class _Optimizer(ast.NodeTransformer):
+    # Python has a built-in AST optimizer that can fold constant expressions like `100 & 1`
+    # just fine. However, it does not optimize some expressions, e.g. `x << 0` or `x & 1 & 1`
+    # because, while they can be algebraically simplified, there is no way to communicate that
+    # `x: int`, which is a precondition. However, we know this precondition holds, so we can
+    # just do it ourselves. Fortunately, the amount of pathological expressions we emit is low.
+    def visit_BinOp(self, node):
+        if type(node.op) in (ast.LShift, ast.RShift):
+            if type(node.right) is ast.Num and node.right.n == 0:
+                node.left = self.visit(node.left)
+        elif type(node.op) is (ast.BitAnd, ast.BitOr):
+            left = self.visit(node.left)
+            if type(left) is ast.BinOp and type(left.op) is type(node.op):
+                if type(node.right) is ast.Num and type(left.right) is ast.Num:
+                    if node.right.n == left.right.n:
+                        return left
+        elif type(node.op) is ast.Mult:
+            if type(node.right) is ast.Num and node.right.n == 1:
+                return self.visit(node.left)
+        return self.generic_visit(node)
+
+
 class _Compiler:
     def __init__(self, context, emitter):
         self.context = context
@@ -750,7 +774,10 @@ class _FragmentCompiler:
                 emitter.append(f"slots[{signal_index}].set(next_{signal_index})")
 
             exec_locals = {"slots": domain_process.context.slots, **_ValueCompiler.helpers}
-            exec(emitter.flush(), exec_locals)
+            code = emitter.flush()
+            if sys.flags.optimize > 0:
+                code = _Optimizer().visit(ast.parse(code))
+            exec(compile(code, domain_process.name, "exec"), exec_locals)
             domain_process.run = exec_locals["run"]
 
             processes.add(domain_process)