Polaris: Directive.h Source File

Directive.h Go to the documentation of this file. /// /// #ifndef _DIRECTIVE_H #define _DIRECTIVE_H /// /// \class Directive /// \brief a base class for compiler directives. /// \defgroup C /// \ingroup C++ CVDL /// Polaris /// \see Directive/Directive.h /// \see Directive/Directive.h /// /// \endcode /// \section Description Description /// The Directive class is meant to provide the base for a generic compiler /// directive class. Derived classes will implement specific instances of /// the different flavors of compiler directives. /// /// \endcode /// \section Bugs Bugs /// No known bugs. /// #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif /// #include <stream.h> #include <strstream.h> /// #include "../Boolean.h" #include "../Listable.h" #include "../String.h" #include "../StringElem.h" #include "../Collection/List.h" /// class BlockEntryStmt; class BlockExitStmt; class StmtList; enum DirectiveType { DT_NONE = 0, DT_CSRD, DT_HPF, DT_CRAY, ///< = 3 DT_KSR, DT_CONVEX, DT_SGI, ///< = 6 DT_CONVEX_SPP, ///< = 7 DT_CEDAR_FORTRAN, DT_CRAY_T3D, ///< = 9 DT_COMMENT, DT_CF_F77, DT_SGI_POWER, ///< = 12 DT_KAP_SGI, DT_TREADMARKS, ///< = 14 DT_FAST_MESSAGES, ///<Begin OpenMP Modification DT_OMP, ///<End OpenMP Modification DT_ZHU = 25 }; enum DirectiveState { DS_NONE, DS_PARSED, DS_GENERATED }; class ProgramUnit; class Statement; class Expression; class DirectiveList; class Assertion; class AssertionList; class Directive : public Listable { friend class DirectiveList; friend inline ostream & operator << (ostream & o, const Directive & d) { d.print(o); return o; } protected: DirectiveType _dtype; DirectiveState _dstate; List<StringElem> _text; List<StringElem> _tokens; AssertionList *_alist; ///< really a reference. void generate_recurrence_directive( Statement &s, Assertion &ap ); ///< generate a RECURRENCE directive. void generate_comment_directive( Statement &s, Assertion &ap ); ///< generate a COMMENT directive. void generate_csrd_shared_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ SHARED directive void generate_csrd_induction_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ INDUCTION directive void generate_csrd_parcondition_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ PARALLEL CONDITION directive void generate_csrd_maymod_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ MAYMOD directive void generate_csrd_nomod_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ NOMOD directive void generate_csrd_looplabel_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ LOOPLABEL directive void generate_csrd_schedule_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ SCHEDULE directive void generate_csrd_private_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ PRIVATE directive. void generate_csrd_dep_WFvsRO_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ DEP_WF_VS_RO directive void generate_csrd_dep_RWvsWF_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ DEP_RW_VS_WF directive void generate_csrd_dep_ROvsRW_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ DEP_RO_VS_RW directive void generate_csrd_dep_overlap_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ DEP_OVERLAP directive void generate_csrd_private_descr_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ PRIVATE_DESCR directive void generate_csrd_test_monotone_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ TEST_MONOTONE directive void generate_csrd_reduct_descr_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ REDUCTION_DESCR directive void generate_csrd_overlap_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ OVERLAP directive void generate_csrd_overlap_sort_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ OVERLAP_SORT directive void generate_csrd_safe_condition_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ SAFE_CONDITION directive. void generate_csrd_assert_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ ASSERT directive. void generate_csrd_serial_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ SERIAL directive. void generate_csrd_critical_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ CRITICAL directive. void generate_csrd_reduction_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ REDUCTION directive. void generate_csrd_dynlastvalue_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ DYN LAST VALUE directive. void generate_csrd_lastvalue_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ LAST VALUE directive. void generate_csrd_nodependence_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ NO_DEPENDENCE directive void generate_csrd_sideeffectfree_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ SIDE_EFFECT_FREE directive void generate_csrd_rangewritten_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ RANGE WRITTEN directive void generate_csrd_firstvalue_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ FIRST VALUE directive. void Directive::generate_csrd_forward_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ FORWARD directive void generate_csrd_privaterefs_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ PRIVATE_REFS directive. void generate_csrd_readonlyrefs_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ READ_ONLY_REFS directive. void generate_csrd_sharedrefs_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ SHARED_REFS directive. void generate_csrd_prologue_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ EPILOGUE directive. void generate_csrd_epilogue_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ PROLOGUE directive. void generate_csrd_parallel_directive( Statement &s, Assertion &ap ); ///< generate a CSRD$ PARALLEL directive. void generate_csrd_preamble_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ PREAMBLE directive void generate_csrd_postamble_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ POSTAMBLE directive void generate_csrd_instrument_directive( Statement &s, Assertion &a ); ///< generate a CSRD$ INSTRUMENT directive void generate_csrd_rtshadow_directive( Statement &s, Assertion &a ); ///< generate CSRD$ RTSHADOW directive void generate_csrd_dep_io_directive( Statement &s, Assertion &a ); ///< generate CSRD$ DEP_IO directive void generate_csrd_inline_directive( Statement &s, Assertion &a ); ///< generate CSRD$ INLINE directive void generate_csrd_recursive_inline_directive( Statement &s, Assertion &a ); ///< generate CSRD$ RECURSIVE INLINE directive void generate_csrd_noinline_directive( Statement &s, Assertion &a ); ///< generate CSRD$ NOINLINE directive void generate_csrd_noputget_directive( Statement &s, Assertion &a ); ///< generate CSRD$ NOPUTGET directive void generate_csrd_runtimetest_directive( Statement &s, Assertion &a ); ///< generate CSRD$ RUN_TIME_TEST directive void generate_comment_directive( Statement &s ); ///< generate a COMMENT directive. void generate_csrd_directive( Statement &s ); ///< generate a list of CONVEX directives. void generate_convex_private_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX PRIVATE directive. void generate_convex_serial_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX PRIVATE directive. void generate_convex_reduction_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX REDUCTION directive. void generate_convex_lastvalue_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX LAST VALUE directive. void generate_convex_prologue_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX EPILOGUE directive. void generate_convex_epilogue_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX PROLOGUE directive. void generate_convex_parallel_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX PARALLEL directive. void generate_convex_directive( Statement &s ); ///< generate a list of CONVEX directives. void generate_sgi_prologue_directive( Statement &s, Assertion &ap ); ///< generate a SGI EPILOGUE directive. void generate_sgi_epilogue_directive( Statement &s, Assertion &ap ); ///< generate a SGI PROLOGUE directive. void generate_sgi_parallel_directive( Statement &s, Assertion &ap ); ///< generate a SGI PARALLEL directive. void generate_sgi_directive( Statement &s ); ///< generate a list of SGI directives. ///<Begin OpenMP Modification ///<Generate the !$OMP PARALLEL directive: void generate_omp_parallel_directive(Statement &s, Assertion& a); ///<Generate the !$OMP DO/END DO directives: void generate_omp_do_directive(Statement &s, Assertion &a); ///<Generate the !$OMP END PARALLEL directive: void generate_omp_end_parallel_directive(Statement &s, Assertion &a); ///<Generate the !$OMP CRITICAL/END CRITICAL directives: void generate_omp_critical_directive(Statement &s, Assertion &a); ///<Generate the !$OMP directives: void generate_omp_directive(Statement &s); ///<Breaks the directives into 72 character lines void break_line(char * sentinel, char * subdir, strstream& o); ///<End OpenMP Modification void generate_hpf_directive( Statement &s ); ///< generate a list of CHPF$ directives. void generate_cray_directive( Statement &s ); ///< generate a list of CDIR$ directives. void generate_ksr_directive( Statement &s ); ///< generate a list of C*KSR* directives. ///<_ ----------------------------------------------------------------------- void generate_cray_t3d_shared_directive( Statement &s, Assertion &a ); void generate_cray_t3d_private_directive( Statement &s, Assertion &a ); void generate_cray_t3d_directive( Statement &s ); ///< generate a list of CDIR$ directives. void generate_convex_spp_private_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX SPP PRIVATE directive. void generate_convex_spp_serial_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX SPP PRIVATE directive. void generate_convex_spp_critical_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX SPP CRITICAL directive. void generate_convex_spp_reduction_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX SPP REDUCTION directive. void generate_convex_spp_lastvalue_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX SPP LAST VALUE directive. void generate_convex_spp_parallel_directive( Statement &s, Assertion &ap ); ///< generate a CONVEX SPP PARALLEL directive. void generate_convex_spp_nodependence_directive( Statement &s, Assertion &ap ); ///<> ///< generate a CONVEX SPP NODEPENDENCE directive. //> void generate_convex_spp_directive( Statement &s ); ///< generate a list of CONVEX SPP C$DIR directives. void generate_convex_spp_nosideeffect_directive( Statement &s, Assertion &ap ); ///< generate a C$DIR NO_SIDE_EFFECT directive public: Directive(DirectiveType dt = DT_NONE); ///< Construct a Directive. Directive(String & s, DirectiveType dt = DT_NONE); ///< Construct a Directive with the string s. Directive(List<StringElem> & sl, DirectiveType dt = DT_NONE); ///< Construct a Directive with the list of strings sl. Directive(const Directive & d); ///< Construct a Directive with a copy of another Directive's current value. Directive(const AssertionList &a, DirectiveType dt = DT_CSRD); ///< Construct a Directive from an assertion list with machine type dt. int lines() const; ///< return the number of lines in the directive buffer. const List<StringElem> & text_list() const; List<StringElem> & text_list(); ///< return the list of text strings associated with this directive. virtual ~Directive(); ///< destructor void generate( Statement &s ); ///< generate the text lines from the internal data. virtual Directive & operator = (const Directive &d); ///< assignment operator. virtual void print(ostream &o) const; ///< print the object. virtual void write(ostream &o) const; ///< write the object. virtual Listable *listable_clone() const; ///< needed for Listable public: ///< This wants to be private, but should be public for now. ///< Needed by the parser to insert BLOCK_* statements static void _ins_after(StmtList &stmts, Statement *curr_stmt, Statement *ref_stmt, char *method_name); ///< Need by the parser to update BLOCK_* links static void _set_follow_fields(BlockEntryStmt &entry, BlockExitStmt &exit); }; #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:45 2005