Merge pull request #4736 from romainbrenguier/clean-up/ssa_exprt

Clean-up ssa-exprt

Author: romainbrenguier

src/util/ssa_expr.cpp

@@ -13,6 +13,43 @@ Author: Daniel Kroening, [email protected]
 
 #include <util/arith_tools.h>
 
+/// If \p expr is:
+/// - a symbol_exprt "s" add "s" to the stream \p os
+///   - a member_exprt, apply recursively and add "..component_name"
+///   - an index_exprt where the index is a constant, apply recursively on the
+///     array and add "[[index]]"
+/// \return the stream \p os
+static std::ostream &
+initialize_ssa_identifier(std::ostream &os, const exprt &expr)
+{
+  if(auto member = expr_try_dynamic_cast<member_exprt>(expr))
+  {
+    return initialize_ssa_identifier(os, member->struct_op())
+           << ".." << member->get_component_name();
+  }
+  if(auto index = expr_try_dynamic_cast<index_exprt>(expr))
+  {
+    const auto idx =
+      numeric_cast_v<mp_integer>(to_constant_expr(index->index()));
+    return initialize_ssa_identifier(os, index->array()) << "[[" << idx << "]]";
+  }
+  if(auto symbol = expr_try_dynamic_cast<symbol_exprt>(expr))
+    return os << symbol->get_identifier();
+
+  UNREACHABLE;
+}
+
+ssa_exprt::ssa_exprt(const exprt &expr) : symbol_exprt(expr.type())
+{
+  set(ID_C_SSA_symbol, true);
+  add(ID_expression, expr);
+  std::ostringstream os;
+  initialize_ssa_identifier(os, expr);
+  const std::string id = os.str();
+  set_identifier(id);
+  set(ID_L1_object_identifier, id);
+}
+
 /// If \p expr is a symbol "s" add to \p os "s!l0@l1#l2" and to \p l1_object_os
 /// "s!l0@l1".
 /// If \p expr is a member or index expression, recursively apply the procedure
@@ -75,20 +112,6 @@ static void build_ssa_identifier_rec(
     UNREACHABLE;
 }
 
-/* Used to determine whether or not an identifier can be built
-   * before trying and getting an exception */
-bool ssa_exprt::can_build_identifier(const exprt &expr)
-{
-  if(expr.id()==ID_symbol)
-    return true;
-  else if(expr.id() == ID_member)
-    return can_build_identifier(to_member_expr(expr).compound());
-  else if(expr.id() == ID_index)
-    return can_build_identifier(to_index_expr(expr).array());
-  else
-    return false;
-}
-
 static std::pair<irep_idt, irep_idt> build_identifier(
   const exprt &expr,
   const irep_idt &l0,
@@ -103,13 +126,97 @@ static std::pair<irep_idt, irep_idt> build_identifier(
   return std::make_pair(irep_idt(oss.str()), irep_idt(l1_object_oss.str()));
 }
 
-void ssa_exprt::update_identifier()
+static void update_identifier(ssa_exprt &ssa)
+{
+  const irep_idt &l0 = ssa.get_level_0();
+  const irep_idt &l1 = ssa.get_level_1();
+  const irep_idt &l2 = ssa.get_level_2();
+
+  auto idpair = build_identifier(ssa.get_original_expr(), l0, l1, l2);
+  ssa.set_identifier(idpair.first);
+  ssa.set(ID_L1_object_identifier, idpair.second);
+}
+
+void ssa_exprt::set_expression(const exprt &expr)
+{
+  type() = expr.type();
+  add(ID_expression, expr);
+  ::update_identifier(*this);
+}
+
+irep_idt ssa_exprt::get_object_name() const
+{
+  const exprt &original_expr = get_original_expr();
+
+  if(original_expr.id() == ID_symbol)
+    return to_symbol_expr(original_expr).get_identifier();
+
+  object_descriptor_exprt ode(original_expr);
+  return to_symbol_expr(ode.root_object()).get_identifier();
+}
+
+const ssa_exprt ssa_exprt::get_l1_object() const
+{
+  object_descriptor_exprt ode(get_original_expr());
+
+  ssa_exprt root(ode.root_object());
+  root.set(ID_L0, get(ID_L0));
+  root.set(ID_L1, get(ID_L1));
+  ::update_identifier(root);
+
+  return root;
+}
+
+const irep_idt ssa_exprt::get_l1_object_identifier() const
+{
+#if 0
+  return get_l1_object().get_identifier();
+#else
+  // the above is the clean version, this is the fast one, using
+  // an identifier cached during build_identifier
+  return get(ID_L1_object_identifier);
+#endif
+}
+
+void ssa_exprt::set_level_0(unsigned i)
 {
-  const irep_idt &l0 = get_level_0();
-  const irep_idt &l1 = get_level_1();
-  const irep_idt &l2 = get_level_2();
+  set(ID_L0, i);
+  ::update_identifier(*this);
+}
+
+void ssa_exprt::set_level_1(unsigned i)
+{
+  set(ID_L1, i);
+  ::update_identifier(*this);
+}
 
-  auto idpair = build_identifier(get_original_expr(), l0, l1, l2);
-  set_identifier(idpair.first);
-  set(ID_L1_object_identifier, idpair.second);
+void ssa_exprt::set_level_2(unsigned i)
+{
+  set(ID_L2, i);
+  ::update_identifier(*this);
+}
+
+void ssa_exprt::remove_level_2()
+{
+  remove(ID_L2);
+  set_identifier(get_l1_object_identifier());
+}
+
+/* Used to determine whether or not an identifier can be built
+   * before trying and getting an exception */
+bool ssa_exprt::can_build_identifier(const exprt &expr)
+{
+  if(expr.id() == ID_symbol)
+    return true;
+  else if(expr.id() == ID_member)
+    return can_build_identifier(to_member_expr(expr).compound());
+  else if(expr.id() == ID_index)
+    return can_build_identifier(to_index_expr(expr).array());
+  else
+    return false;
+}
+
+void ssa_exprt::update_identifier()
+{
+  ::update_identifier(*this);
 }

src/util/ssa_expr.h

@@ -17,13 +17,13 @@ class ssa_exprt:public symbol_exprt
 {
 public:
   /// Constructor
-  /// \param expr: Expression to be converted to SSA symbol
-  explicit ssa_exprt(const exprt &expr) : symbol_exprt(expr.type())
-  {
-    set(ID_C_SSA_symbol, true);
-    add(ID_expression, expr);
-    update_identifier();
-  }
+  /// \param expr: Expression to be converted to SSA symbol. A valid argument
+  ///   must be one of these:
+  ///   - a symbol_exprt
+  ///   - a member_exprt where the accessed struct would be a valid argument
+  ///   - an index_exprt where the index is a constant and the array would be
+  ///     a valid argument
+  explicit ssa_exprt(const exprt &expr);
 
   void update_type()
   {
@@ -38,76 +38,27 @@ class ssa_exprt:public symbol_exprt
   /// Replace the underlying, original expression by \p expr while maintaining
   /// SSA indices.
   /// \param expr: expression to store
-  void set_expression(const exprt &expr)
-  {
-    type() = expr.type();
-    add(ID_expression, expr);
-    update_identifier();
-  }
-
-  irep_idt get_object_name() const
-  {
-    const exprt &original_expr = get_original_expr();
-
-    if(original_expr.id() == ID_symbol)
-      return to_symbol_expr(original_expr).get_identifier();
-
-    object_descriptor_exprt ode(original_expr);
-    return to_symbol_expr(ode.root_object()).get_identifier();
-  }
-
-  const ssa_exprt get_l1_object() const
-  {
-    object_descriptor_exprt ode(get_original_expr());
+  void set_expression(const exprt &expr);
 
-    ssa_exprt root(ode.root_object());
-    root.set(ID_L0, get(ID_L0));
-    root.set(ID_L1, get(ID_L1));
-    root.update_identifier();
+  irep_idt get_object_name() const;
 
-    return root;
-  }
+  const ssa_exprt get_l1_object() const;
 
-  const irep_idt get_l1_object_identifier() const
-  {
-    #if 0
-    return get_l1_object().get_identifier();
-    #else
-    // the above is the clean version, this is the fast one, using
-    // an identifier cached during build_identifier
-    return get(ID_L1_object_identifier);
-    #endif
-  }
+  const irep_idt get_l1_object_identifier() const;
 
   const irep_idt get_original_name() const
   {
     ssa_exprt o(get_original_expr());
     return o.get_identifier();
   }
 
-  void set_level_0(unsigned i)
-  {
-    set(ID_L0, i);
-    update_identifier();
-  }
+  void set_level_0(unsigned i);
 
-  void set_level_1(unsigned i)
-  {
-    set(ID_L1, i);
-    update_identifier();
-  }
+  void set_level_1(unsigned i);
 
-  void set_level_2(unsigned i)
-  {
-    set(ID_L2, i);
-    update_identifier();
-  }
+  void set_level_2(unsigned i);
 
-  void remove_level_2()
-  {
-    remove(ID_L2);
-    set_identifier(get_l1_object_identifier());
-  }
+  void remove_level_2();
 
   const irep_idt get_level_0() const
   {
@@ -124,6 +75,7 @@ class ssa_exprt:public symbol_exprt
     return get(ID_L2);
   }
 
+  DEPRECATED(SINCE(2019, 05, 29, "Should only be used internally"))
   void update_identifier();
 
   /// Used to determine whether or not an identifier can be built before trying