introduce instructiont::dead_symbol()

This mirrors the change in #5861 by replacing the use of code_deadt by
directly returning the symbol_exprt.  The client code is simplified.

Author: kroening

src/analyses/constant_propagator.cpp

@@ -191,8 +191,7 @@ void constant_propagator_domaint::transform(
   }
   else if(from->is_dead())
   {
-    const auto &code_dead = from->get_dead();
-    values.set_to_top(code_dead.symbol());
+    values.set_to_top(from->dead_symbol());
   }
   else if(from->is_function_call())
   {

src/analyses/custom_bitvector_analysis.cpp

@@ -304,14 +304,11 @@ void custom_bitvector_domaint::transform(
     break;
 
   case DEAD:
-    {
-      const code_deadt &code_dead=to_code_dead(instruction.code);
-      assign_lhs(code_dead.symbol(), vectorst());
+    assign_lhs(instruction.dead_symbol(), vectorst());
 
-      // is it a pointer?
-      if(code_dead.symbol().type().id()==ID_pointer)
-        assign_lhs(dereference_exprt(code_dead.symbol()), vectorst());
-    }
+    // is it a pointer?
+    if(instruction.dead_symbol().type().id() == ID_pointer)
+      assign_lhs(dereference_exprt(instruction.dead_symbol()), vectorst());
     break;
 
   case FUNCTION_CALL:

src/analyses/escape_analysis.cpp

@@ -210,11 +210,8 @@ void escape_domaint::transform(
     break;
 
   case DEAD:
-    {
-      const code_deadt &code_dead=to_code_dead(instruction.code);
-      aliases.isolate(code_dead.get_identifier());
-      assign_lhs_cleanup(code_dead.symbol(), std::set<irep_idt>());
-    }
+    aliases.isolate(instruction.dead_symbol().get_identifier());
+    assign_lhs_cleanup(instruction.dead_symbol(), std::set<irep_idt>());
     break;
 
   case FUNCTION_CALL:
@@ -487,14 +484,14 @@ void escape_analysist::instrument(
       }
       else if(instruction.type == DEAD)
       {
-        const code_deadt &code_dead = to_code_dead(instruction.code);
+        const auto &dead_symbol = instruction.dead_symbol();
 
         std::set<irep_idt> cleanup_functions1;
 
         const escape_domaint &d = operator[](i_it);
 
         const escape_domaint::cleanup_mapt::const_iterator m_it =
-          d.cleanup_map.find("&" + id2string(code_dead.get_identifier()));
+          d.cleanup_map.find("&" + id2string(dead_symbol.get_identifier()));
 
         // does it have a cleanup function for the object?
         if(m_it != d.cleanup_map.end())
@@ -506,22 +503,12 @@ void escape_analysist::instrument(
 
         std::set<irep_idt> cleanup_functions2;
 
-        d.check_lhs(code_dead.symbol(), cleanup_functions2);
+        d.check_lhs(dead_symbol, cleanup_functions2);
 
         insert_cleanup(
-          gf_entry.second,
-          i_it,
-          code_dead.symbol(),
-          cleanup_functions1,
-          true,
-          ns);
+          gf_entry.second, i_it, dead_symbol, cleanup_functions1, true, ns);
         insert_cleanup(
-          gf_entry.second,
-          i_it,
-          code_dead.symbol(),
-          cleanup_functions2,
-          false,
-          ns);
+          gf_entry.second, i_it, dead_symbol, cleanup_functions2, false, ns);
 
         for(const auto &c : cleanup_functions1)
         {

src/analyses/global_may_alias.cpp

@@ -127,11 +127,8 @@ void global_may_alias_domaint::transform(
   }
 
   case DEAD:
-  {
-    const code_deadt &code_dead = to_code_dead(instruction.code);
-    aliases.isolate(code_dead.get_identifier());
+    aliases.isolate(instruction.dead_symbol().get_identifier());
     break;
-  }
 
   case FUNCTION_CALL: // Probably safe
   case GOTO:          // Ignoring the guard is a valid over-approximation

src/analyses/goto_rw.cpp

@@ -815,10 +815,7 @@ void goto_rw(
 
   case DEAD:
     rw_set.get_objects_rec(
-      function,
-      target,
-      rw_range_sett::get_modet::LHS_W,
-      to_code_dead(target->code).symbol());
+      function, target, rw_range_sett::get_modet::LHS_W, target->dead_symbol());
     break;
 
   case DECL:

src/analyses/interval_domain.cpp

@@ -75,7 +75,7 @@ void interval_domaint::transform(
     break;
 
   case DEAD:
-    havoc_rec(to_code_dead(instruction.code).symbol());
+    havoc_rec(instruction.dead_symbol());
     break;
 
   case ASSIGN:

src/analyses/local_bitvector_analysis.cpp

@@ -293,15 +293,12 @@ void local_bitvector_analysist::build()
     }
 
     case DEAD:
-    {
-      const code_deadt &code_dead = to_code_dead(instruction.code);
       assign_lhs(
-        code_dead.symbol(),
+        instruction.dead_symbol(),
         exprt(ID_uninitialized),
         loc_info_src,
         loc_info_dest);
       break;
-    }
 
     case FUNCTION_CALL:
     {

src/analyses/local_may_alias.cpp

@@ -390,11 +390,9 @@ void local_may_aliast::build(const goto_functiont &goto_function)
     }
 
     case DEAD:
-    {
-      const code_deadt &code_dead = to_code_dead(instruction.code);
-      assign_lhs(code_dead.symbol(), nil_exprt(), loc_info_src, loc_info_dest);
+      assign_lhs(
+        instruction.dead_symbol(), nil_exprt(), loc_info_src, loc_info_dest);
       break;
-    }
 
     case FUNCTION_CALL:
     {

src/analyses/reaching_definitions.cpp

@@ -169,7 +169,7 @@ void rd_range_domaint::transform_dead(
   const namespacet &,
   locationt from)
 {
-  const irep_idt &identifier = to_code_dead(from->code).get_identifier();
+  const irep_idt &identifier = from->dead_symbol().get_identifier();
 
   valuest::iterator entry=values.find(identifier);
 

src/analyses/variable-sensitivity/variable_sensitivity_domain.cpp

@@ -55,16 +55,10 @@ void variable_sensitivity_domaint::transform(
   break;
 
   case DEAD:
-  {
     // Remove symbol from map, the only time this occurs now (keep TOP.)
     // It should be the case that DEAD only provides symbols for deletion.
-    const exprt &expr = to_code_dead(instruction.code).symbol();
-    if(expr.id() == ID_symbol)
-    {
-      abstract_state.erase(to_symbol_expr(expr));
-    }
-  }
-  break;
+    abstract_state.erase(instruction.dead_symbol());
+    break;
 
   case ASSIGN:
   {