omp_lowering.h

Go to the documentation of this file.

#include "astQuery.h"
//#include "sage3basic.h"

#ifndef OMP_LOWERING_H
#define OMP_LOWERING_H 
namespace OmpSupport
{
  // We support both Omni and GCC OpenMP runtime libraries
  enum omp_rtl_enum 
  {
    e_gomp,
    e_omni,
    e_last_rtl
  };
  extern unsigned int nCounter; // translation generated variable counter, used to avoid name collision

  extern omp_rtl_enum rtl_type; 
  typedef std::map<const SgVariableSymbol *, SgVariableSymbol *> VariableSymbolMap_t;

  void commandLineProcessing(std::vector<std::string> &argvList);

  void lower_omp(SgSourceFile*);


  void insertRTLHeaders(SgSourceFile*);

  void insertRTLinitAndCleanCode(SgSourceFile* ); 

  class translationDriver: public AstSimpleProcessing
  { 
    protected:
      void visit(SgNode*);
  }; //translationDriver

  void transOmpParallel(SgNode* node);

  void transOmpSections(SgNode* node);

  void transOmpTask(SgNode* node);

  void transOmpLoop(SgNode* node);

  //void transOmpDo(SgNode* node);


  void transOmpBarrier(SgNode* node);

  void transOmpFlush(SgNode* node);

  void transOmpTaskwait(SgNode* node);

  void transOmpThreadprivate(SgNode* node);

  void transOmpOrdered(SgNode* node);
  void transOmpAtomic(SgNode* node);
  void transOmpCritical(SgNode* node);
  void transOmpMaster(SgNode* node);
  void transOmpSingle(SgNode* node);

 // It calls the ROSE AST outliner internally. 
 SgFunctionDeclaration* generateOutlinedTask(SgNode* node, std::string& wrapper_name, std::set<SgVariableSymbol*>& syms, std::set<SgInitializedName*>& readOnlyVars);
 
  void transOmpVariables(SgStatement * ompStmt, SgBasicBlock* bb1, SgExpression* orig_loop_upper = NULL);

  SgInitializedNamePtrList collectAllClauseVariables (SgOmpClauseBodyStatement * clause_stmt);

  SgInitializedNamePtrList collectClauseVariables (SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);

  SgInitializedNamePtrList collectClauseVariables (SgOmpClauseBodyStatement * clause_stmt, const VariantVector& vvt);

  bool isInClauseVariableList(SgInitializedName* var, SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);

  bool isInClauseVariableList(SgInitializedName* var, SgOmpClauseBodyStatement * clause_stmt, const VariantVector& vvt);

  int replaceVariableReferences(SgNode* root, SgVariableSymbol* oldVar, SgVariableSymbol* newVar);

  int replaceVariableReferences(SgNode* root,  VariableSymbolMap_t varRemap);
  // I decided to reuse the existing Outliner work instead of coding a new one
  //SgFunctionDeclaration* generateOutlinedFunction(SgNode* node);
  
  void addClauseVariable(SgInitializedName* var, SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);

  SgOmpVariablesClause* buildOmpVariableClause(SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);

  bool hasClause(SgOmpClauseBodyStatement* clause_stmt, const VariantT & vt);

  Rose_STL_Container<SgOmpClause*>  getClause(SgOmpClauseBodyStatement* clause_stmt, const VariantT & vt);

  bool useStaticSchedule(SgOmpClauseBodyStatement* omp_loop);

  SgOmpClause::omp_reduction_operator_enum getReductionOperationType(SgInitializedName* init_name, SgOmpClauseBodyStatement* clause_stmt);

  SgExpression* createInitialValueExp(SgOmpClause::omp_reduction_operator_enum r_operator);

  std::string generateGOMPLoopStartFuncName (bool isOrdered, SgOmpClause::omp_schedule_kind_enum s_kind);

  std::string generateGOMPLoopNextFuncName (bool isOrdered, SgOmpClause::omp_schedule_kind_enum s_kind);

  std::string toString(SgOmpClause::omp_schedule_kind_enum s_kind);

  int patchUpPrivateVariables(SgFile*);

  int patchUpFirstprivateVariables(SgFile*);

  std::set<SgInitializedName*> collectThreadprivateVariables();

  SgVariableDeclaration * buildAndInsertDeclarationForOmp(const std::string &name, SgType *type, SgInitializer *varInit, SgBasicBlock *orig_scope);
  SgBasicBlock* getEnclosingRegionOrFuncDefinition (SgNode *);
} // end namespace OmpSupport  

#endif //OMP_LOWERING_H

---