C++ goto_programt::update方法代码示例

bool remove_virtual_functionst::remove_virtual_functions(
  goto_programt &goto_program)
{
  bool did_something=false;

  Forall_goto_program_instructions(target, goto_program)
    if(target->is_function_call())
    {
      const code_function_callt &code=
        to_code_function_call(target->code);

      if(code.function().id()==ID_virtual_function)
      {
        remove_virtual_function(goto_program, target);
        did_something=true;
      }
    }

  if(did_something)
  {
    goto_program.update();
  }

  return did_something;
}

void string_instrumentationt::do_function_call(
  goto_programt &dest,
  goto_programt::targett target)
{
  code_function_callt &call=
    to_code_function_call(target->code);
  exprt &function=call.function();
  //const exprt &lhs=call.lhs();
  
  if(function.id()=="symbol")
  {
    const irep_idt &identifier=
      to_symbol_expr(function).get_identifier();

    if(identifier=="c::strcoll")
    {
    }
    else if(identifier=="c::strncmp")
      do_strncmp(dest, target, call);
    else if(identifier=="c::strxfrm")
    {
    }
    else if(identifier=="c::strchr")
      do_strchr(dest, target, call);
    else if(identifier=="c::strcspn")
    {
    }
    else if(identifier=="c::strpbrk")
    {
    }
    else if(identifier=="c::strrchr")
      do_strrchr(dest, target, call);
    else if(identifier=="c::strspn")
    {
    }
    else if(identifier=="c::strerror")
      do_strerror(dest, target, call);
    else if(identifier=="c::strstr")
      do_strstr(dest, target, call);
    else if(identifier=="c::strtok")
      do_strtok(dest, target, call);
    else if(identifier=="c::sprintf")
      do_sprintf(dest, target, call);
    else if(identifier=="c::snprintf")
      do_snprintf(dest, target, call);
    else if(identifier=="c::fscanf")
      do_fscanf(dest, target, call);
    
    dest.update();
  }
}

void loop_transformt::transform(goto_programt &goto_program)
{
  goto_program.compute_incoming_edges();

  // pass 1: simple stuff
  Forall_goto_program_instructions(it, goto_program)
    if(it->is_backwards_goto())
    {
      assert(it->targets.size()==1);

      goto_programt::targett begin = it->targets.front();
      goto_programt::targett end = it;

      split_multi_head(goto_program, begin, end);
      transform_do_while(goto_program, begin, end);
      move_returns(goto_program, begin, end);
    }

  // pass 2: loop simulation
  Forall_goto_program_instructions(it, goto_program)
    if(it->is_backwards_goto())
    {
      goto_programt::targett begin = it->targets.front();
      goto_programt::targett end = it;

      std::set<goto_programt::targett> entries;
      std::set<goto_programt::targett> exits;

      analyze(goto_program, begin, end, entries, exits);
      transform(goto_program, begin, end, entries, exits);

      it=end;
    }

  goto_program.update();

  #if 1
  // Another run for debugging
  forall_goto_program_instructions(it, goto_program)
    if(it->is_backwards_goto())
    {
      goto_programt::const_targett begin = it->targets.front();
      goto_programt::const_targett end = it;

      run_checks(goto_program, begin, end);
    }
  #endif
}

void loop_transformt::move_returns(
  goto_programt &program,
  goto_programt::targett begin,
  goto_programt::targett end)
{
  goto_programt::targett postend = end; postend++;

  std::list<goto_programt::targett> returns;

  for(goto_programt::targett it = begin;
      it!=end;
      it++)
  {
    if(it->is_return())
      returns.push_back(it);
  }

  if(returns.size()>0)
  {
    for(std::list<goto_programt::targett>::const_iterator it = returns.begin();
        it!=returns.end();
        it++)
    {

      goto_programt::targett newret = program.insert_before(postend);
      newret->swap(**it);
      newret->location_number = postend->location_number;      

      (*it)->make_goto(newret);
      // this creates far exits,
      // which will be fixed lateron
    }

    // fix the loop exit
    goto_programt::targett firstafter = end; firstafter++;
    goto_programt::targett loopexit = program.insert_before(firstafter);
    loopexit->make_goto(postend);
    
    program.update();
  }
}

void loop_transformt::transform_do_while(
  goto_programt &program,
  goto_programt::targett &begin,
  goto_programt::targett &end) const
{
  if(!end->guard.is_true())
  {
    #if 0
    std::cout << "TRANSFORM DO-WHILE" << std::endl;
    #endif

    goto_programt::targett next = end; next++;
    assert(next!=program.instructions.end());

    goto_programt::instructiont newguard;
    newguard.make_goto(next);
    newguard.guard = end->guard;
    newguard.guard.make_not();
    newguard.location = end->location;
    end->guard.make_true();

    unsigned ln = end->location_number; // doesn't get swapped
    program.insert_before_swap(end, newguard); // end now points to the new guard

    goto_programt::targett old_guard = end; old_guard++;
    end->location_number=ln;
    old_guard->location_number=ln;

    program.update();

    #if 0
    std::cout << "Transformed: " << std::endl;
    goto_programt::const_targett it = begin;
    for (;
         it!=end;
         it++)
      program.output_instruction(ns, "", std::cout, it);
    program.output_instruction(ns, "", std::cout, it);
    #endif
  }
}

void convert( const irept &irep, goto_programt &program )
{
  assert(irep.id()=="goto-program");

  program.instructions.clear();

  std::list< std::list<unsigned> > number_targets_list;

  // convert instructions back
  const irept::subt &subs = irep.get_sub();
  for (irept::subt::const_iterator it=subs.begin();
       it!=subs.end();
       it++)
  {
    program.instructions.push_back(goto_programt::instructiont());
    convert(*it, program.instructions.back());

    number_targets_list.push_back(std::list<unsigned>());
    const irept &targets=it->find(ID_targets);
    const irept::subt &tsubs=targets.get_sub();
    for (irept::subt::const_iterator tit=tsubs.begin();
         tit!=tsubs.end();
         tit++)
    {
      number_targets_list.back().push_back(
          unsafe_string2unsigned(tit->id_string()));
    }
  }

  program.compute_location_numbers();

  // resolve targets
  std::list< std::list<unsigned> >::iterator nit=
        number_targets_list.begin();
  for(goto_programt::instructionst::iterator lit=
        program.instructions.begin();
      lit!=program.instructions.end() && nit!=number_targets_list.end();
      lit++, nit++)
  {
    for (std::list<unsigned>::iterator tit=nit->begin();
         tit!=nit->end();
         tit++)
    {
      goto_programt::targett fit=program.instructions.begin();
      for(;fit!=program.instructions.end();fit++)
      {
        if (fit->location_number==*tit)
        {
          lit->targets.push_back(fit);
          break;
        }
      }

      if (fit==program.instructions.end())
      {
        std::cout << "Warning: could not resolve target link "
                  << "during irep->goto_program translation." << std::endl;
        throw 0;
      }
    }
  }

  program.update();
}

void loop_transformt::split_multi_head(
  goto_programt &program,
  goto_programt::targett begin,
  goto_programt::targett end)
{
  #if 0
  std::cout << "SPLIT MULTI-HEAD (" << begin->incoming_edges.size() <<
    ")" << std::endl;
  #endif

  unsigned dontmatter = 0;
  goto_programt::targett prev = begin; prev--;
  
  forall_incoming_edges(it, begin)  
  {
    if((*it)==prev) dontmatter++;
    else if((*it)==end) dontmatter++;
  }
  
  if(begin->incoming_edges.size() > dontmatter)
  {
    #if 0
    std::cout << "Splitting " << begin->incoming_edges.size() <<
      "-head" << std::endl;
    #endif

    goto_programt::targett newskip = program.insert_before(begin);

    newskip->make_skip();
    newskip->location_number = begin->location_number;
    newskip->function = begin->function;
    newskip->location = begin->location;

    // redirect gotos
    forall_incoming_edges(it, begin)    
    {
      const goto_programt::targett &from = *it;
      
      if(from!=prev && from!=end &&
         from->is_goto() &&
         from->targets.front()==begin) // gotos right before the loop
                                       // aren't necessarily jumping to begin
      {
        assert(from->targets.size()==1);
        
        from->targets.clear();
        from->targets.push_back(newskip);
      }
    }

    program.update();

    #if 0
    namespacet ns(context);
    std::cout << "Split loop: " << std::endl;
    goto_programt::const_targett it = newskip;
    for (;
         it!=end;
         it++)
      program.output_instruction(ns, "", std::cout, it);
    program.output_instruction(ns, "", std::cout, it);
    #endif

    assert(begin->incoming_edges.size()<=2);
  }

//.........这里部分代码省略.........

    xmlt::elementst::const_iterator eit = it->elements.begin();
    for(; eit != it->elements.end(); eit++)
    {
      if(eit->name=="location")
      {
        convert(*eit, inst->location);
      }
      else if(eit->name=="variables")
      {
      }
      else if(eit->name=="labels")
      {
        xmlt::elementst::const_iterator lit = eit->elements.begin();
        for(; lit != eit->elements.end(); lit++)
        {
          if(lit->name=="label")
          {
            std::string ls = lit->get_attribute("name");
            inst->labels.push_back(ls);
          }
          else
          {
            std::cout << "Unknown node in labels section." << std::endl;
            return;
          }
        }
      }
      else if(eit->name=="guard")
      {
        inst->guard.remove("value");
        convert(*eit, inst->guard);
      }
      else if(eit->name=="code")
      {
        convert(*eit, inst->code);
      }
      else if(eit->name=="targets")
      {
        // Don't do anything here, we'll need a second run for that
      }
      else if(eit->name=="comment")
      {
        inst->location.set("comment", eit->data);
      }
      else if(eit->name=="function")
      {
        inst->function = eit->data;
      }
    }
  }

  // assign line numbers
  goto_program.compute_location_numbers();

  // second run, for targets
  goto_programt::targett ins_it = instructions.begin();
  it = xml.elements.begin();
  for(; it != xml.elements.end() && ins_it!=instructions.end(); it++)
  {
    xmlt::elementst::const_iterator eit = it->elements.begin();
    for(; eit != it->elements.end(); eit++)
    {
      if(eit->name=="targets")
      {
        xmlt::elementst::const_iterator tit = eit->elements.begin();
        for(; tit != eit->elements.end(); tit++)
        {
          if(tit->name=="target")
          {
            goto_programt::targett tins =
              find_instruction(xml, instructions, tit->data);
            if(tins != instructions.end())
            {
              // Here we insert the iterators that somehow seem
              // to be strange afterwards (see line 87)
              ins_it->targets.push_back(tins);
            }
            else
            {
              std::cout << "Warning: instruction not found when "
              "resolving target links." << std::endl;
            }
          }
          else
          {
            std::cout << "Unknown node in targets section." << std::endl;
            return;
          }
        }
      }
    }
    ins_it++;
  }

  // resolve links
  goto_program.update();

  // std::cout << "TNI: " << goto_program.target_numbers.size() << std::endl;
}