inst-solver-gen.py

#!/usr/bin/env python
##
## This file is part of Nolimips, a MIPS simulator with unlimited registers
## Copyright (C) 2003, 2004 Benoit Perrot <benoit@lrde.epita.fr>
##
## Nolimips is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
## 
## Nolimips is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
## 
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##

import sys, os
import string, re

import nolimips
from nolimips import license, depth, class_id

#### Nolimips' program solver generator --------------------

if __name__ != "__main__" or len(sys.argv) != 2:
  print "Usage: .. SRCDIR"
  sys.exit(1)
srcdir = sys.argv[1]

parser = nolimips.InstructionSetParser()
instructions = parser.parse(sys.stdin)


## Generate interface
sys.stdout = file("program_solver.hh.tmp", "w")

print license
print """#ifndef INST_PROGRAM_SOLVER_HH
# define INST_PROGRAM_SOLVER_HH

# include "config.h"

# include <stdint.h>

# include \"common.hh\"

# include \"inst/exp-visitor.hh\"
# include \"inst/exp.hh\"
# include \"inst/visitor.hh\"
# include \"inst/all.hh\"
# include \"inst/program.hh\"

// FIXME: dirty access unlimited registers flag
# include \"parse/libparse.hh\"

namespace inst
{

  class ProgramSolver:
    protected Visitor, 
    protected ExpVisitor
  {
  public:
    ProgramSolver():
      program_(0),
      max_callee_save_(8), max_caller_save_(10)
    {}
    virtual ~ProgramSolver()
    {}

  public:
    void set_max_callee_save(int max_callee_save)
    {
      max_callee_save_ = max_callee_save;
    }
    void set_max_caller_save(int max_caller_save)
    {
      max_caller_save_ = max_caller_save;
    }

  public:
    void	solve(Program &program)
    {
      program_ = &program;

      pc_ = 4;
      for (TextSection::instruction_list_type::const_iterator
             it = program.text_section().begin();
             it != program.text_section().end(); ++it, pc_ += 4)
	(*it)->accept(*this);
    }
  protected:
    int		pc_;

  protected:
    void	solve_exp(Exp &exp)
    {
      exp.accept(*this);
    }

    virtual void	visit(IntExp &i);
    virtual void	visit(LabelExp &l);
    virtual void	visit(OpExp &o);

  protected:
    void	solve_cpu_register(Register &reg) const;
    void	solve_cop_register(Register &reg) const;
"""

print "  protected:"
for inst in instructions:
  if inst.level == "native":
    print "    virtual void	visit(" +\
          nolimips.class_id(inst.opcode) + " &);"
    
print """
  protected:
    Program	*program_;

    int max_callee_save_;
    int max_caller_save_;
  };

} // namespace inst

#endif // !INST_PROGRAM_SOLVER_HH
"""

sys.stdout.close()
sys.stdout = sys.__stdout__
nolimips.lazy_overwrite(srcdir + os.sep + "program_solver.hh",
                        "program_solver.hh.tmp")
os.remove("program_solver.hh.tmp")


## Generate implementation
sys.stdout = file("program_solver.cc.tmp", "w")

print license
print """#include \"inst/program_solver.hh\"
#include \"inst/int_exp.hh\"
#include \"inst/label_exp.hh\"
#include \"inst/op_exp.hh\"

#include \"vm/cpu.hh\"

namespace inst
{
  void
  ProgramSolver::visit(IntExp &i)
  {
    i.set_immediate(i.get_integer());
  }

  void
  ProgramSolver::visit(LabelExp &l)
  {
    if (! program_->data_section().has_label(l.get_name()))
      if (! program_->text_section().has_label(l.get_name()))
	{
	  std::cerr << \"Undefined label: \" << l.get_name()
		    << std::endl;
	  exit_set(exit_solve);
	}
      else
	l.set_immediate(program_->text_section().
			get_offset(l.get_name()) - pc_);
    else
      l.set_immediate(program_->data_section().get_offset(l.get_name()));
  }

  void
  ProgramSolver::visit(OpExp &o)
  {
    o.get_left().accept(*this);
    o.get_right().accept(*this);
    switch (o.kind_)
      {
      case OpExp::add:
	o.set_immediate(o.get_left().get_immediate() + 
			o.get_right().get_immediate());
	break;
      case OpExp::sub:
	o.set_immediate(o.get_left().get_immediate() - 
			o.get_right().get_immediate());
	break;
      case OpExp::mul: 
	o.set_immediate(o.get_left().get_immediate() * 
			o.get_right().get_immediate());
	break;
      case OpExp::div:
	o.set_immediate(o.get_left().get_immediate() / 
			o.get_right().get_immediate());
	break;
      }
  }

  void
  ProgramSolver::solve_cpu_register(Register &reg) const
  {
    switch (reg.get_kind())
      {
      case Register::generic:
	reg.set_kind(Register::general);
      case Register::general:
	if ((reg.get_index() == vm::Cpu::t9 && max_caller_save_ < 10)
	    || (reg.get_index() == vm::Cpu::t8 && max_caller_save_ < 9)
	    || (vm::Cpu::t0 + max_caller_save_ - 1 < reg.get_index()
		&& reg.get_index() <= vm::Cpu::t7))
	  {
	    std::cerr << \"Caller-save register limited.\" << std::endl;
	    exit_set(exit_solve);
	  }
	else if (vm::Cpu::s0 + max_callee_save_ - 1 < reg.get_index() &&
		 reg.get_index() <= vm::Cpu::s7)
	  {
	    std::cerr << \"Callee-save register limited.\" << std::endl;
	    exit_set(exit_solve);
	  }
	break;
      case Register::unlimited:
	if (!parse::unlimited_regs_p)
	  {
	    std::cerr << \"Unlimited registers prohibited.\" << std::endl;
	    exit_set(exit_solve);
	  }
	break;
      };
  }
    
  void
  ProgramSolver::solve_cop_register(Register &reg) const
  {
    if (reg.get_kind() != Register::generic)
      {
	std::cerr << \"Coprocessor registers must be generic.\" << std::endl;
	exit_set(exit_solve);
      }
  }

"""

for inst in instructions:
  if inst.level == "native":
    var_id = nolimips.var_id(inst.opcode)
    
    content = ""
    for attribute in inst.format.attributes:
      if attribute.type == "Exp":
        content = content + "    solve_exp(" + \
                  var_id + ".get_" + attribute.name + "());\n"
      elif attribute.type == "Register":
        if attribute.restriction == "generic":
          content = content + "    solve_cop_register("
        else:
          content = content + "    solve_cpu_register("
        content = content + var_id + ".get_" + attribute.name + "());\n"
    
    print "  void"
    if content != "":
      print "  ProgramSolver::visit(" + nolimips.class_id(inst.opcode) + \
            " &" + var_id + ")"
      print "  {\n" + content + "  }"
    else:
      print "  ProgramSolver::visit(" + nolimips.class_id(inst.opcode) + " &)"
      print "  {"
      print "  }"
  
print """
} // namespace inst"""

sys.stdout.close()
sys.stdout = sys.__stdout__
nolimips.lazy_overwrite(srcdir + os.sep + "program_solver.cc",
                        "program_solver.cc.tmp")
os.remove("program_solver.cc.tmp")