Merge pull request #3502 from tautschnig/irept-rvalue-add-set

Enable perfect forwarding with irept/exprt/typet constructors

Author: tautschnig

src/util/dstring.h

@@ -71,6 +71,18 @@ class dstringt final
   {
   }
 
+  dstringt(const dstringt &) = default;
+
+  /// Move constructor. There is no need and no point in actually destroying the
+  /// source object \p other, this is effectively just a copy constructor.
+#ifdef __GNUC__
+  constexpr
+#endif
+    dstringt(dstringt &&other)
+    : no(other.no)
+  {
+  }
+
   // access
 
   bool empty() const
@@ -136,6 +148,14 @@ class dstringt final
   dstringt &operator=(const dstringt &b)
   { no=b.no; return *this; }
 
+  /// Move assignment. There is no need and no point in actually destroying the
+  /// source object \p other, this is effectively just an assignment.
+  dstringt &operator=(dstringt &&other)
+  {
+    no = other.no;
+    return *this;
+  }
+
   // output
 
   std::ostream &operator<<(std::ostream &out) const;

src/util/expr.h

@@ -57,9 +57,18 @@ class exprt:public irept
   // constructors
   exprt() { }
   explicit exprt(const irep_idt &_id):irept(_id) { }
-  exprt(const irep_idt &_id, const typet &_type):irept(_id)
+
+  exprt(irep_idt _id, typet _type)
+    : irept(std::move(_id), {{ID_type, std::move(_type)}}, {})
+  {
+  }
+
+  exprt(irep_idt _id, typet _type, operandst &&_operands)
+    : irept(
+        std::move(_id),
+        {{ID_type, std::move(_type)}},
+        std::move((irept::subt &&) _operands))
   {
-    add(ID_type, _type);
   }
 
   /// Return the type of the expression
@@ -324,7 +333,13 @@ class expr_protectedt : public exprt
 {
 protected:
   // constructors
-  expr_protectedt(const irep_idt &_id, const typet &_type) : exprt(_id, _type)
+  expr_protectedt(irep_idt _id, typet _type)
+    : exprt(std::move(_id), std::move(_type))
+  {
+  }
+
+  expr_protectedt(irep_idt _id, typet _type, operandst _operands)
+    : exprt(std::move(_id), std::move(_type), std::move(_operands))
   {
   }
 

src/util/irep.cpp

@@ -189,7 +189,7 @@ irept &irept::add(const irep_namet &name)
 #endif
 }
 
-irept &irept::add(const irep_namet &name, const irept &irep)
+irept &irept::add(const irep_namet &name, irept irep)
 {
   named_subt &s = get_named_sub();
 
@@ -202,18 +202,20 @@ irept &irept::add(const irep_namet &name, const irept &irep)
     named_subt::iterator before = s.before_begin();
     while(std::next(before) != it)
       ++before;
-    it = s.emplace_after(before, name, irep);
+    it = s.emplace_after(before, name, std::move(irep));
   }
   else
-    it->second=irep;
+    it->second = std::move(irep);
 
   return it->second;
 #else
-  std::pair<named_subt::iterator, bool> entry=
-    s.insert(std::make_pair(name, irep));
+  std::pair<named_subt::iterator, bool> entry = s.emplace(
+    std::piecewise_construct,
+    std::forward_as_tuple(name),
+    std::forward_as_tuple(irep));
 
   if(!entry.second)
-    entry.first->second=irep;
+    entry.first->second = std::move(irep);
 
   return entry.first->second;
 #endif

src/util/irep.h

@@ -421,7 +421,7 @@ class irept
 
   const irept &find(const irep_namet &name) const;
   irept &add(const irep_namet &name);
-  irept &add(const irep_namet &name, const irept &irep);
+  irept &add(const irep_namet &name, irept irep);
 
   const std::string &get_string(const irep_namet &name) const
   {
@@ -435,9 +435,13 @@ class irept
   long long get_long_long(const irep_namet &name) const;
 
   void set(const irep_namet &name, const irep_idt &value)
-  { add(name).id(value); }
-  void set(const irep_namet &name, const irept &irep)
-  { add(name, irep); }
+  {
+    add(name, irept(value));
+  }
+  void set(const irep_namet &name, irept irep)
+  {
+    add(name, std::move(irep));
+  }
   void set(const irep_namet &name, const long long value);
 
   void remove(const irep_namet &name);

src/util/ssa_expr.h

@@ -18,7 +18,7 @@ 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(irep_idt(), expr.type())
+  explicit ssa_exprt(const exprt &expr) : symbol_exprt(expr.type())
   {
     set(ID_C_SSA_symbol, true);
     add(ID_expression, expr);
@@ -42,15 +42,13 @@ class ssa_exprt:public symbol_exprt
     if(original_expr.id() == ID_symbol)
       return to_symbol_expr(original_expr).get_identifier();
 
-    object_descriptor_exprt ode;
-    ode.object() = original_expr;
+    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;
-    ode.object()=get_original_expr();
+    object_descriptor_exprt ode(get_original_expr());
 
     ssa_exprt root(ode.root_object());
     root.set(ID_L0, get(ID_L0));