procedure.h

Go to the documentation of this file.

#ifndef BDWY_PROCEDURE_H
#define BDWY_PROCEDURE_H

// ----------------------------------------------------------------------
//   Procedure Annotation
// ----------------------------------------------------------------------

#ifdef __PROCLOCATION
typedef std::set< procLocation * > proclocation_set;
typedef proclocation_set::iterator proclocation_set_p;
typedef proclocation_set::const_iterator proclocation_set_cp;
#endif

#ifdef _CALLSITEENTRY
class callsiteEntry
{
private:

  threeAddrNode * _stmt;

  operandNode * _call;

#ifdef __PROCLOCATION
  proclocation_set _contexts;
#endif

public:

  callsiteEntry(threeAddrNode * stmt, operandNode * call)
    : _stmt(stmt),
      _call(call),
      _contexts()
  {}

  inline threeAddrNode * stmt() const { return _stmt; }
  inline operandNode * call() const { return _call; }

#ifdef __PROCLOCATION
  inline proclocation_set & contexts() { return _contexts; }
#endif
};

typedef std::map< threeAddrNode *, callsiteEntry * > callsite_map;
typedef callsite_map::iterator callsite_map_p;
typedef callsite_map::const_iterator callsite_map_cp;

#endif /* _CALLSITEENTRY */

typedef std::set< enumPropertyAnn * > enum_property_set;
typedef enum_property_set::iterator enum_property_set_p;
typedef enum_property_set::const_iterator enum_property_set_cp;

typedef std::map< annVariable *, enum_property_set > variable_property_map;
typedef variable_property_map::iterator variable_property_map_p;
typedef variable_property_map::const_iterator variable_property_map_cp;


class procedureAnn : public Ann
{
public:

  static procedureAnn * Current;

private:

  std::string _name;

  TREE var_map _variables;

  REF var_list _formal_params;

  REF var_set _uses;

  REF var_set _defs;

  REF var_set _global_uses;

  REF var_set _global_defs;

  REF variable_property_map _property_uses;

  REF variable_property_map _property_defs;

  REF variable_property_map _property_weak_defs;


  TREE structure_list _on_entry;
  TREE structure_list _on_exit;


  TREE pointerrule_list _pointer_rules;

  REF pointerRuleAnn * _default_pointer_rule;

  TREE analyze_map   _analyses;

  TREE report_list _reports;

#ifdef __ACTIONS
  TREE action_list _actions;
#endif

#ifdef __PROCNODE 
  TREE procNode * _proc;
#endif

  REF idnodeann_list _numeric_identifiers;

  REF Annotations * _annotations;

#ifdef __CALLSITE_MAP
  TREE callsite_map _callsites;
#endif


  bool _pure_function;
  bool _allocates_memory;
  bool _deallocates_memory;
  bool _modifies_globals;
  bool _accesses_io;


public:

  procedureAnn(parserID * name, parserid_list * params, Annotations * anns,
               const int line);

  ~procedureAnn();


  inline const std::string & name() const { return _name; }

  inline const var_map & variables() const { return _variables; }

  inline const var_set & uses() const { return _uses; }
  inline const var_set & defs() const { return _defs; }

  inline const var_list & formal_params() const { return _formal_params; }

  inline const structure_list & on_entry() const { return _on_entry; }
  inline const structure_list & on_exit()  const { return _on_exit; }

  inline const pointerrule_list & pointer_rules() const { return _pointer_rules; }
  inline pointerRuleAnn * default_pointer_rule() const { return _default_pointer_rule; }

  inline const analyze_map & analyses() const { return _analyses; }

  inline const report_list & reports() const { return _reports; }

#ifdef __ACTIONS
  inline const action_list & actions() const { return _actions; }
#endif

#ifdef __PROCNODE 
  inline procNode * proc() const { return _proc; }
#endif
  inline idnodeann_list & numeric_identifiers() { return _numeric_identifiers; }

#ifdef __CALLSITE_MAP
  inline const callsite_map & callsites() const { return _callsites; }
#endif

  inline bool pure_function() const { return _pure_function; }
  inline bool allocates_memory() const { return _allocates_memory; }
  inline bool deallocates_memory() const { return _deallocates_memory; }
  inline bool modifies_globals() const { return _modifies_globals; }
  inline bool accesses_io() const { return _accesses_io; }


  annVariable * lookup(const std::string & variable, bool create, bool is_new = false);

  // --- Manage uses and defs -----------------------

  void add_defs(parserid_list * variables);

  void add_one_def(annVariable * var);

  void add_uses(parserid_list * variables);

  void add_one_use(annVariable * var);

#ifdef __PROCLOCATION
  stmtLocation * def_use_location(procLocation * procloc);
#endif

#ifdef __PROCLOCATION
  stmtLocation * dealloc_location(procLocation * procloc);
#endif

#ifdef __PROCLOCATION
  stmtLocation * alloc_location(procLocation * procloc);
#endif


  // --- Manage property uses and defs -----------------------

  void add_property_use(annVariable * var, enumPropertyAnn * enum_property);

  inline const variable_property_map & property_uses() const { return _property_uses; }

  void add_property_def(annVariable * var, enumPropertyAnn * enum_property);

  inline const variable_property_map & property_defs() const { return _property_defs; }

  void add_property_weak_def(annVariable * var, enumPropertyAnn * enum_property);

  inline const variable_property_map & property_weak_defs() const { return _property_weak_defs; }

  // ---------------------------------------

  void add_delete(parserID * id);

  void postprocess();

  void add_on_entry(structuretree_list * structures); 

  void add_on_exit(structuretree_list * structures);

  void add_on_exit(pointerRuleAnn * pointer_rule);

  void add_global_structures(Annotations * annotations,
                             annVariable * parent_var,
                             structureTreeAnn * parent_node);

  void add_analysis(analyzeAnn * new_analysis);

#ifdef __PROCLOCATION
  void add_calling_context(operandNode * call, procLocation * where);
#endif

  void add_report(reportAnn * report);

  void add_action(actionAnn * action);

#ifdef __CALLSITE_MAP
  callsiteEntry * find_callsite(threeAddrNode * stmt);
#endif

  void process_reports(Analyzer * analyzer);

  void test_actions(Analyzer * analyzer);

#ifdef __CALLSITE_MAP
  actionAnn * find_applicable_action(threeAddrNode * stmt);
#endif

  void clear();

  // --- Output

  friend std::ostream& operator<<(std::ostream & o, const procedureAnn & pa) {
    pa.print(o);
    return o;
  }

  void print(std::ostream & o) const;

private:

  void add_structures(bool is_on_entry,
                      structure_list & the_list,
                      annVariable * parent_var,
                      structureTreeAnn * parent_node);


  parserid_list * _temp_defs;
  parserid_list * _temp_uses;
  parserid_list * _temp_deletes;


  void postprocess_variables(parserid_list & uses_or_defs,
                             bool is_defs);
};
  
#endif /*  */