Replace some uses of forall_operands by ranged-for

In some (but not all!) cases of forall_operands we do not actually need the
iterator.

Author: tautschnig

jbmc/src/java_bytecode/ci_lazy_methods.cpp

@@ -526,8 +526,10 @@ void ci_lazy_methodst::gather_needed_globals(
     }
   }
   else
-    forall_operands(opit, e)
-      gather_needed_globals(*opit, symbol_table, needed);
+  {
+    for(const auto &op : e.operands())
+      gather_needed_globals(op, symbol_table, needed);
+  }
 }
 
 /// Find a virtual callee, if one is defined and the callee type is known to

jbmc/src/java_bytecode/java_bytecode_convert_method.cpp

@@ -976,8 +976,8 @@ static void gather_symbol_live_ranges(
   }
   else
   {
-    forall_operands(it, e)
-      gather_symbol_live_ranges(pc, *it, result);
+    for(const auto &op : e.operands())
+      gather_symbol_live_ranges(pc, op, result);
   }
 }
 

jbmc/src/java_bytecode/java_bytecode_instrument.cpp

@@ -449,9 +449,9 @@ optionalt<codet> java_bytecode_instrumentt::instrument_expr(const exprt &expr)
 {
   code_blockt result;
   // First check our operands:
-  forall_operands(it, expr)
+  for(const auto &op : expr.operands())
   {
-    if(optionalt<codet> op_result = instrument_expr(*it))
+    if(optionalt<codet> op_result = instrument_expr(op))
       result.add(std::move(*op_result));
   }
 

src/analyses/constant_propagator.cpp

@@ -324,9 +324,9 @@ bool constant_propagator_domaint::two_way_propagate_rec(
     {
       change_this_time = false;
 
-      forall_operands(it, expr)
+      for(const auto &op : expr.operands())
       {
-        change_this_time |= two_way_propagate_rec(*it, ns, cp);
+        change_this_time |= two_way_propagate_rec(op, ns, cp);
         if(change_this_time)
           change = true;
       }

src/analyses/custom_bitvector_analysis.cpp

@@ -690,9 +690,11 @@ bool custom_bitvector_domaint::has_get_must_or_may(const exprt &src)
   if(src.id() == ID_get_must || src.id() == ID_get_may)
     return true;
 
-  forall_operands(it, src)
-    if(has_get_must_or_may(*it))
+  for(const auto &op : src.operands())
+  {
+    if(has_get_must_or_may(op))
       return true;
+  }
 
   return false;
 }

src/analyses/dirty.cpp

@@ -31,8 +31,8 @@ void dirtyt::find_dirty(const exprt &expr)
     return;
   }
 
-  forall_operands(it, expr)
-    find_dirty(*it);
+  for(const auto &op : expr.operands())
+    find_dirty(op);
 }
 
 void dirtyt::find_dirty_address_of(const exprt &expr)

src/analyses/goto_check.cpp

@@ -1729,8 +1729,8 @@ void goto_checkt::check_rec(const exprt &expr, guardt &guard)
       return;
   }
 
-  forall_operands(it, expr)
-    check_rec(*it, guard);
+  for(const auto &op : expr.operands())
+    check_rec(op, guard);
 
   if(expr.type().id() == ID_c_enum_tag)
     enum_range_check(expr, guard);

src/analyses/goto_rw.cpp

@@ -309,8 +309,8 @@ void rw_range_sett::get_objects_array(
     sub_size = to_range_spect(*subtype_bits);
   else
   {
-    forall_operands(it, expr)
-      get_objects_rec(mode, *it, 0, -1);
+    for(const auto &op : expr.operands())
+      get_objects_rec(mode, op, 0, -1);
 
     return;
   }
@@ -320,15 +320,15 @@ void rw_range_sett::get_objects_array(
   range_spect full_r_e=
     size==-1 ? sub_size*expr.operands().size() : full_r_s+size;
 
-  forall_operands(it, expr)
+  for(const auto &op : expr.operands())
   {
     if(full_r_s<=offset+sub_size && full_r_e>offset)
     {
       range_spect cur_r_s=full_r_s<=offset ? 0 : full_r_s-offset;
       range_spect cur_r_e=
         full_r_e>offset+sub_size ? sub_size : full_r_e-offset;
 
-      get_objects_rec(mode, *it, cur_r_s, cur_r_e-cur_r_s);
+      get_objects_rec(mode, op, cur_r_s, cur_r_e - cur_r_s);
     }
 
     offset+=sub_size;
@@ -353,23 +353,23 @@ void rw_range_sett::get_objects_struct(
   range_spect full_r_s=range_start==-1 ? 0 : range_start;
   range_spect full_r_e=size==-1 || full_size==-1 ? -1 : full_r_s+size;
 
-  forall_operands(it, expr)
+  for(const auto &op : expr.operands())
   {
-    auto it_bits = pointer_offset_bits(it->type(), ns);
+    auto it_bits = pointer_offset_bits(op.type(), ns);
 
     range_spect sub_size = it_bits.has_value() ? to_range_spect(*it_bits) : -1;
 
     if(offset==-1)
     {
-      get_objects_rec(mode, *it, 0, sub_size);
+      get_objects_rec(mode, op, 0, sub_size);
     }
     else if(sub_size==-1)
     {
       if(full_r_e==-1 || full_r_e>offset)
       {
         range_spect cur_r_s=full_r_s<=offset ? 0 : full_r_s-offset;
 
-        get_objects_rec(mode, *it, cur_r_s, -1);
+        get_objects_rec(mode, op, cur_r_s, -1);
       }
 
       offset=-1;
@@ -380,7 +380,7 @@ void rw_range_sett::get_objects_struct(
       {
         range_spect cur_r_s=full_r_s<=offset ? 0 : full_r_s-offset;
 
-        get_objects_rec(mode, *it, cur_r_s, sub_size-cur_r_s);
+        get_objects_rec(mode, op, cur_r_s, sub_size - cur_r_s);
       }
 
       offset+=sub_size;
@@ -391,7 +391,7 @@ void rw_range_sett::get_objects_struct(
       range_spect cur_r_e=
         full_r_e>offset+sub_size ? sub_size : full_r_e-offset;
 
-      get_objects_rec(mode, *it, cur_r_s, cur_r_e-cur_r_s);
+      get_objects_rec(mode, op, cur_r_s, cur_r_e - cur_r_s);
 
       offset+=sub_size;
     }
@@ -576,8 +576,8 @@ void rw_range_sett::get_objects_rec(
     // possibly affects the full object size, even if range_start/size
     // are only a subset of the bytes (e.g., when using the result of
     // arithmetic operations)
-    forall_operands(it, expr)
-      get_objects_rec(mode, *it);
+    for(const auto &op : expr.operands())
+      get_objects_rec(mode, op);
   }
   else if(expr.id() == ID_null_object ||
           expr.id() == ID_string_constant)
@@ -586,8 +586,8 @@ void rw_range_sett::get_objects_rec(
   }
   else if(mode==get_modet::LHS_W)
   {
-    forall_operands(it, expr)
-      get_objects_rec(mode, *it);
+    for(const auto &op : expr.operands())
+      get_objects_rec(mode, op);
   }
   else
     throw "rw_range_sett: assignment to '" + expr.id_string() + "' not handled";

src/analyses/interval_domain.cpp

@@ -391,14 +391,18 @@ void interval_domaint::assume_rec(
   else if(cond.id()==ID_and)
   {
     if(!negation)
-      forall_operands(it, cond)
-        assume_rec(*it, false);
+    {
+      for(const auto &op : cond.operands())
+        assume_rec(op, false);
+    }
   }
   else if(cond.id()==ID_or)
   {
     if(negation)
-      forall_operands(it, cond)
-        assume_rec(*it, true);
+    {
+      for(const auto &op : cond.operands())
+        assume_rec(op, true);
+    }
   }
 }
 

src/analyses/invariant_set.cpp

@@ -410,8 +410,8 @@ void invariant_sett::strengthen_rec(const exprt &expr)
   }
   else if(expr.id()==ID_and)
   {
-    forall_operands(it, expr)
-      strengthen_rec(*it);
+    for(const auto &op : expr.operands())
+      strengthen_rec(op);
   }
   else if(expr.id()==ID_le ||
           expr.id()==ID_lt)
@@ -425,10 +425,10 @@ void invariant_sett::strengthen_rec(const exprt &expr)
     {
       const exprt &bitand_op = rel.op1();
 
-      forall_operands(it, bitand_op)
+      for(const auto &op : bitand_op.operands())
       {
         auto tmp(rel);
-        tmp.op1()=*it;
+        tmp.op1() = op;
         strengthen_rec(tmp);
       }
 
@@ -500,10 +500,10 @@ void invariant_sett::strengthen_rec(const exprt &expr)
     {
       const exprt &bitand_op = equal_expr.op1();
 
-      forall_operands(it, bitand_op)
+      for(const auto &op : bitand_op.operands())
       {
         auto tmp(equal_expr);
-        tmp.op1()=*it;
+        tmp.op1() = op;
         tmp.id(ID_le);
         strengthen_rec(tmp);
       }
@@ -603,17 +603,21 @@ tvt invariant_sett::implies_rec(const exprt &expr) const
   }
   else if(expr.id()==ID_and)
   {
-    forall_operands(it, expr)
-      if(implies_rec(*it)!=tvt(true))
+    for(const auto &op : expr.operands())
+    {
+      if(implies_rec(op) != tvt(true))
         return tvt::unknown();
+    }
 
     return tvt(true);
   }
   else if(expr.id()==ID_or)
   {
-    forall_operands(it, expr)
-      if(implies_rec(*it)==tvt(true))
+    for(const auto &op : expr.operands())
+    {
+      if(implies_rec(op) == tvt(true))
         return tvt(true);
+    }
   }
   else if(expr.id()==ID_le ||
           expr.id()==ID_lt ||
@@ -1050,8 +1054,8 @@ void invariant_sett::apply_code(const codet &code)
 
   if(statement==ID_block)
   {
-    forall_operands(it, code)
-      apply_code(to_code(*it));
+    for(const auto &op : code.operands())
+      apply_code(to_code(op));
   }
   else if(statement==ID_assign)
   {