code: def dead_code_elimination(graph, du, ud):
      
      for node in graph.rpo:
          for i, ins in node.get_loc_with_ins():
              reg = ins.get_lhs()
              if reg is not None:
                  # If the definition is not used, we check that the instruction
                  # has no side effect. If there is one and this is a call, we
                  # remove only the unused defined variable. else, this is
                  # something like an array access, so we do nothing.
                  # Otherwise (no side effect) we can remove the instruction from
                  # the node.
                  if (reg, i) not in du:
                      if ins.is_call():
                          ins.remove_defined_var()
                      elif ins.has_side_effect():
                          continue
                      else:
                          # We can delete the instruction. First update the DU
                          # chain of the variables used by the instruction to
                          # `let them know` that they are not used anymore by the
                          # deleted instruction.
                          # Then remove the instruction.
                          update_chain(graph, i, du, ud)
                          graph.remove_ins(i)
docs: Run a dead code elimination pass.
      Instructions are checked to be dead. If it is the case, we remove them and
      we update the DU & UD chains of its variables to check for further dead
      instructions.