does_remove_const.cpp

Go to the documentation of this file.

/*******************************************************************\
 
Module: Analyses
 
Author: Diffblue Ltd.
 
\*******************************************************************/
 
 
#include "does_remove_const.h"
 
#include <goto-programs/goto_program.h>
 
#include <util/pointer_expr.h>
#include <util/std_code.h>
 
does_remove_constt::does_remove_constt(const goto_programt &goto_program)
  : goto_program(goto_program)
{}
 
std::pair<bool, source_locationt> does_remove_constt::operator()() const
{
  for(const goto_programt::instructiont &instruction :
    goto_program.instructions)
  {
    if(!instruction.is_assign())
    {
      continue;
    }
 
    const typet &rhs_type = instruction.assign_rhs().type();
    const typet &lhs_type = instruction.assign_lhs().type();
 
    // Compare the types recursively for a point where the rhs is more
    // const that the lhs
    if(!does_type_preserve_const_correctness(&lhs_type, &rhs_type))
    {
      return {true, instruction.source_location()};
    }
 
    if(does_expr_lose_const(instruction.assign_rhs()))
    {
      return {true, instruction.assign_rhs().find_source_location()};
    }
  }
 
  return {false, source_locationt()};
}
 
bool does_remove_constt::does_expr_lose_const(const exprt &expr) const
{
  const typet &root_type=expr.type();
 
  // Look in each child that has the same type as the root
  for(const exprt &op : expr.operands())
  {
    const typet &op_type=op.type();
    if(op_type == root_type)
    {
      // Is this child more const-qualified than the root
      if(!does_type_preserve_const_correctness(&root_type, &op_type))
      {
        return true;
      }
    }
 
    // Recursively check the children of this child
    if(does_expr_lose_const(op))
    {
      return true;
    }
  }
  return false;
}
 
bool does_remove_constt::does_type_preserve_const_correctness(
  const typet *target_type, const typet *source_type) const
{
  while(target_type->id()==ID_pointer)
  {
    PRECONDITION(source_type->id() == ID_pointer);
 
    const auto &target_pointer_type = to_pointer_type(*target_type);
    const auto &source_pointer_type = to_pointer_type(*source_type);
 
    bool direct_subtypes_at_least_as_const = is_type_at_least_as_const_as(
      target_pointer_type.base_type(), source_pointer_type.base_type());
    // We have a pointer to something, but the thing it is pointing to can't be
    // modified normally, but can through this pointer
    if(!direct_subtypes_at_least_as_const)
      return false;
    // Check the subtypes if they are pointers
    target_type = &target_pointer_type.base_type();
    source_type = &source_pointer_type.base_type();
  }
  return true;
}
 
bool does_remove_constt::is_type_at_least_as_const_as(
  const typet &type_more_const, const typet &type_compare) const
{
  return !type_compare.get_bool(ID_C_constant) ||
         type_more_const.get_bool(ID_C_constant);
}