Interpreter: de-duplicate code

evaluate_address(byte_extract) and evaluate(byte_extract) had almost the same
implementation.

Author: tautschnig

src/goto-programs/interpreter_evaluate.cpp

@@ -854,42 +854,12 @@ void interpretert::evaluate(
     }
     return;
   }
-  else if(expr.id()==ID_byte_extract_little_endian ||
-          expr.id()==ID_byte_extract_big_endian)
-  {
-    if(expr.operands().size()!=2)
-      throw "byte_extract should have two operands";
-    mp_vectort extract_offset;
-    evaluate(expr.op1(), extract_offset);
-    mp_vectort extract_from;
-    evaluate(expr.op0(), extract_from);
-    if(extract_offset.size()==1 && extract_from.size()!=0)
-    {
-      const typet &target_type=expr.type();
-      mp_integer memory_offset;
-      // If memory offset is found (which should normally be the case)
-      // extract the corresponding data from the appropriate memory location
-      if(!byte_offset_to_memory_offset(
-           expr.op0().type(),
-           extract_offset[0],
-           memory_offset))
-      {
-        mp_integer target_type_leaves;
-        if(!count_type_leaves(target_type, target_type_leaves) &&
-           target_type_leaves>0)
-        {
-          dest.insert(dest.end(),
-            extract_from.begin()+memory_offset.to_long(),
-            extract_from.begin()+(memory_offset+target_type_leaves).to_long());
-          return;
-        }
-      }
-    }
-  }
   else if(expr.id()==ID_dereference ||
           expr.id()==ID_index ||
           expr.id()==ID_symbol ||
-          expr.id()==ID_member)
+          expr.id()==ID_member ||
+          expr.id() == ID_byte_extract_little_endian ||
+          expr.id() == ID_byte_extract_big_endian)
   {
     mp_integer address=evaluate_address(
       expr,
@@ -943,16 +913,40 @@ void interpretert::evaluate(
     }
     else if(!address.is_zero())
     {
+      if(expr.id()==ID_byte_extract_little_endian ||
+         expr.id()==ID_byte_extract_big_endian)
+      {
+        // extract_from will be non-empty, otherwise evaluate_address would have
+        // returned address == 0
+        mp_vectort extract_from;
+        evaluate(expr.op0(), extract_from);
+        const mp_integer memory_offset =
+          address - evaluate_address(expr.op0(), true);
+        const typet &target_type = expr.type();
+        mp_integer target_type_leaves;
+        if(!count_type_leaves(target_type, target_type_leaves) &&
+           target_type_leaves > 0)
+        {
+          dest.insert(
+            dest.end(),
+            extract_from.begin() + numeric_cast_v<std::size_t>(memory_offset),
+            extract_from.begin() +
+              numeric_cast_v<std::size_t>(memory_offset + target_type_leaves));
+          return;
+        }
+        // we fail
+      }
       if(!unbounded_size(expr.type()))
       {
         dest.resize(integer2size_t(get_size(expr.type())));
         read(address, dest);
+        return;
       }
       else
       {
         read_unbounded(address, dest);
+        return;
       }
-      return;
     }
   }
   else if(expr.id()==ID_typecast)