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
{

  // OpenMP version info.
  extern bool enable_accelerator;  



  int patchUpSharedVariables(SgFile* );
  // TODO:  patchUpDefaultVariables(SgFile* );

  int makeDataSharingExplicit( SgFile* );   

  // last edited by Hongyi on 07/24/2012. 

  // 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 transOmpTargetParallel(SgNode* node);

  void transOmpSections(SgNode* node);

  void transOmpTask(SgNode* node);

  void transOmpLoop(SgNode* node);

  void transOmpTargetLoop(SgNode* node);

  //void transOmpDo(SgNode* node);

  void transOmpTarget(SgNode* node);

  void transOmpTargetData(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);

  ROSE_DLL_API void transOmpVariables(SgStatement * ompStmt, SgBasicBlock* bb1, SgExpression* orig_loop_upper = NULL, bool withinAcceleratorModel= false);

  ROSE_DLL_API SgInitializedNamePtrList collectAllClauseVariables (SgOmpClauseBodyStatement * clause_stmt);

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

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

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

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

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

  ROSE_DLL_API 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);

  int replaceVariablesWithPointerDereference(SgNode* root, std::set<SgVariableSymbol*>& vars);
  
  ROSE_DLL_API void addClauseVariable(SgInitializedName* var, SgOmpClauseBodyStatement * clause_stmt, const VariantT& vt);

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

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

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

  ROSE_DLL_API bool useStaticSchedule(SgOmpClauseBodyStatement* omp_loop);

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

  ROSE_DLL_API SgExpression* createInitialValueExp(SgOmpClause::omp_reduction_operator_enum r_operator);

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

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

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

  ROSE_DLL_API int patchUpPrivateVariables(SgFile*);

  ROSE_DLL_API 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