Subversion Repositories openrisc

// dataflow.cc -- Go frontend dataflow.

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

#include "go-system.h"

#include "gogo.h"

#include "expressions.h"

#include "statements.h"

#include "dataflow.h"

// This class is used to traverse the tree to look for uses of

// variables.

class Dataflow_traverse_expressions : public Traverse

{

 public:

  Dataflow_traverse_expressions(Dataflow* dataflow, Statement* statement)

    : Traverse(traverse_blocks | traverse_expressions),

      dataflow_(dataflow), statement_(statement)

  { }

 protected:

  // Only look at top-level expressions: do not descend into blocks.

  // They will be examined via Dataflow_traverse_statements.

  int

  block(Block*)

  { return TRAVERSE_SKIP_COMPONENTS; }

  int

  expression(Expression**);

 private:

  // The dataflow information.

  Dataflow* dataflow_;

  // The Statement in which we are looking.

  Statement* statement_;

};

// Given an expression, return the Named_object that it refers to, if

// it is a local variable.

static Named_object*

get_var(Expression* expr)

{

  Var_expression* ve = expr->var_expression();

  if (ve == NULL)

    return NULL;

  Named_object* no = ve->named_object();

  go_assert(no->is_variable() || no->is_result_variable());

  if (no->is_variable() && no->var_value()->is_global())

    return NULL;

  return no;

}

// Look for a reference to a variable in an expression.

int

Dataflow_traverse_expressions::expression(Expression** expr)

{

  Named_object* no = get_var(*expr);

  if (no != NULL)

    this->dataflow_->add_ref(no, this->statement_);

  return TRAVERSE_CONTINUE;

}

// This class is used to handle an assignment statement.

class Dataflow_traverse_assignment : public Traverse_assignments

{

 public:

  Dataflow_traverse_assignment(Dataflow* dataflow, Statement* statement)

    : dataflow_(dataflow), statement_(statement)

  { }

 protected:

  void

  initialize_variable(Named_object*);

  void

  assignment(Expression** lhs, Expression** rhs);

  void

  value(Expression**, bool, bool);

 private:

  // The dataflow information.

  Dataflow* dataflow_;

  // The Statement in which we are looking.

  Statement* statement_;

};

// Handle a variable initialization.

void

Dataflow_traverse_assignment::initialize_variable(Named_object* var)

{

  Expression* init = var->var_value()->init();

  this->dataflow_->add_def(var, init, this->statement_, true);

  if (init != NULL)

    {

      Expression* e = init;

      this->value(&e, true, true);

      go_assert(e == init);

    }

}

// Handle an assignment in a statement.

void

Dataflow_traverse_assignment::assignment(Expression** plhs, Expression** prhs)

{

  Named_object* no = get_var(*plhs);

  if (no != NULL)

    {

      Expression* rhs = prhs == NULL ? NULL : *prhs;

      this->dataflow_->add_def(no, rhs, this->statement_, false);

    }

  else

    {

      // If this is not a variable it may be some computed lvalue, and

      // we want to look for references to variables in that lvalue.

      this->value(plhs, false, false);

    }

  if (prhs != NULL)

    this->value(prhs, true, false);

}

// Handle a value in a statement.

void

Dataflow_traverse_assignment::value(Expression** pexpr, bool, bool)

{

  Named_object* no = get_var(*pexpr);

  if (no != NULL)

    this->dataflow_->add_ref(no, this->statement_);

  else

    {

      Dataflow_traverse_expressions dte(this->dataflow_, this->statement_);

      Expression::traverse(pexpr, &dte);

    }

}

// This class is used to traverse the tree to look for statements.

class Dataflow_traverse_statements : public Traverse

{

 public:

  Dataflow_traverse_statements(Dataflow* dataflow)

    : Traverse(traverse_statements),

      dataflow_(dataflow)

  { }

 protected:

  int

  statement(Block*, size_t* pindex, Statement*);

 private:

  // The dataflow information.

  Dataflow* dataflow_;

};

// For each Statement, we look for expressions.

int

Dataflow_traverse_statements::statement(Block* block, size_t* pindex,

                                        Statement *statement)

{

  Dataflow_traverse_assignment dta(this->dataflow_, statement);

  if (!statement->traverse_assignments(&dta))

    {

      Dataflow_traverse_expressions dte(this->dataflow_, statement);

      statement->traverse(block, pindex, &dte);

    }

  return TRAVERSE_CONTINUE;

}

// Compare variables.

bool

Dataflow::Compare_vars::operator()(const Named_object* no1,

                                   const Named_object* no2) const

{

  if (no1->name() < no2->name())

    return true;

  if (no1->name() > no2->name())

    return false;

  // We can have two different variables with the same name.

  Location loc1 = no1->location();

  Location loc2 = no2->location();

  if (loc1 < loc2)

    return false;

  if (loc1 > loc2)

    return true;

  if (no1 == no2)

    return false;

  // We can't have two variables with the same name in the same

  // location.

  go_unreachable();

}

// Class Dataflow.

Dataflow::Dataflow()

  : defs_(), refs_()

{

}

// Build the dataflow information.

void

Dataflow::initialize(Gogo* gogo)

{

  Dataflow_traverse_statements dts(this);

  gogo->traverse(&dts);

}

// Add a definition of a variable.

void

Dataflow::add_def(Named_object* var, Expression* val, Statement* statement,

                  bool is_init)

{

  Defs* defnull = NULL;

  std::pair<Defmap::iterator, bool> ins =

    this->defs_.insert(std::make_pair(var, defnull));

  if (ins.second)

    ins.first->second = new Defs;

  Def def;

  def.statement = statement;

  def.val = val;

  def.is_init = is_init;

  ins.first->second->push_back(def);

}

// Add a reference to a variable.

void

Dataflow::add_ref(Named_object* var, Statement* statement)

{

  Refs* refnull = NULL;

  std::pair<Refmap::iterator, bool> ins =

    this->refs_.insert(std::make_pair(var, refnull));

  if (ins.second)

    ins.first->second = new Refs;

  Ref ref;

  ref.statement = statement;

  ins.first->second->push_back(ref);

}

// Return the definitions of a variable.

const Dataflow::Defs*

Dataflow::find_defs(Named_object* var) const

{

  Defmap::const_iterator p = this->defs_.find(var);

  if (p == this->defs_.end())

    return NULL;

  else

    return p->second;

}

// Return the references of a variable.

const Dataflow::Refs*

Dataflow::find_refs(Named_object* var) const

{

  Refmap::const_iterator p = this->refs_.find(var);

  if (p == this->refs_.end())

    return NULL;

  else

    return p->second;

}