Polaris: Directive.cc Source File

00001 ///
00002 #ifdef POLARIS_GNU_PRAGMAS
00003 #pragma implementation
00004 #endif
00005 ///
00006 #include <stdio.h>
00007 #include <stdlib.h>
00008 #include <string.h>
00009 #include <strstream.h>
00010 #include <ctype.h>
00011 
00012 #include "Directive.h"
00013 
00014 #include "Assertion.h"
00015 #include "AssertionList.h"
00016 #include "Assertion.all.h"
00017 #include "RecurrenceAssertion.h"
00018 
00019 #include "../Collection/RefMap.h"
00020 #include "../Expression/Expression.h"
00021 #include "../Statement/Statement.h"
00022 #include "../Statement/BlockEntryStmt.h"
00023 #include "../Statement/BlockExitStmt.h"
00024 #include "../StmtList.h"
00025 #include "../Traverser.h"
00026 #include "../ProgramUnit.h"
00027 
00028 #include "../Collection/Iterator.h"
00029 #include "../Collection/Mutator.h"
00030 #include "../Expression/StringConstExpr.h"
00031 #include "../utilities/switches_util.h"
00032 //Begin OpenMP Modification
00033 #include "../utilities/openmp.h"
00034 //End OpenMP Modification
00035 #include "../macros.h"
00036 #include "../p-assert.h"
00037 
00038 
00039 
00040 Directive::Directive(DirectiveType dt GIV(DT_NONE))
00041 {
00042     _dtype  = dt;
00043     _dstate = DS_NONE;
00044     _alist  = 0;
00045 }
00046 
00047 Directive::Directive(String & s, DirectiveType dt GIV(DT_NONE))
00048 {
00049     StringElem  *e = new StringElem(s);
00050 
00051     _dtype  = dt;
00052     _dstate = DS_NONE;
00053 
00054     _text.ins_first( e );
00055 
00056     _alist  = 0;
00057 }
00058 
00059 Directive::Directive(List<StringElem> & sl, DirectiveType dt GIV(DT_NONE))
00060 {
00061     _dtype  = dt;
00062     _dstate = DS_NONE;
00063 
00064     _text   = sl;
00065 
00066     _alist  = 0;
00067 }
00068 
00069 
00070 Directive::Directive(const Directive & d)
00071 {
00072     _dtype   = d._dtype;
00073     _dstate  = d._dstate;
00074 
00075     _text    = d._text;
00076     _tokens  = d._tokens;
00077 
00078     _alist  = 0;
00079 }
00080 
00081 Directive::Directive(const AssertionList &a, DirectiveType dt GIV(DT_CSRD))
00082 {
00083     _dtype  = dt;
00084     _dstate = DS_NONE;
00085 
00086     _alist  = CASTAWAY(AssertionList *) &a;
00087 }
00088 
00089 Directive::~Directive()
00090 {
00091     _dtype  = DT_NONE;
00092     _dstate = DS_NONE;
00093 
00094     _alist = 0;
00095 }
00096 
00097 int
00098 Directive::lines() const
00099 {
00100     return _text.entries();
00101 }
00102 
00103 const List<StringElem> &
00104 Directive::text_list() const
00105 {
00106     return _text;
00107 }
00108 
00109 List<StringElem> &
00110 Directive::text_list()
00111 {
00112     return _text;
00113 }
00114 
00115 void
00116 Directive::print(ostream &o) const
00117 {
00118     for (Iterator<StringElem> iter = _text; iter.valid(); ++iter) 
00119         o << iter.current() << endl;
00120 }
00121 
00122 void
00123 Directive::write(ostream &o) const
00124 {
00125     for (Iterator<StringElem> iter = _text; iter.valid(); ++iter) 
00126         o << iter.current() << endl;
00127 }
00128 
00129 Directive & 
00130 Directive::operator = (const Directive &d)
00131 {
00132     _dtype = d._dtype;
00133     _dstate = d._dstate;
00134 
00135     _text.clear();
00136     _text = d._text;
00137 
00138     _tokens.clear();
00139     _tokens = d._tokens;
00140 
00141     return (*this);
00142 }
00143 
00144 Listable *
00145 Directive::listable_clone() const
00146 {
00147     return (Listable *) new Directive( *this );
00148 }
00149 
00150 //------------------------------------------------------------------------
00151 
00152 /// This is a kludge for the moment in order to obtain access to 
00153 /// the StmtList's private members.
00154 
00155 void
00156 Directive::_ins_after(StmtList &stmts,
00157               Statement *curr_stmt,
00158               Statement *ref_stmt,
00159               char *method_name) {
00160     stmts._ins_after(curr_stmt, ref_stmt, method_name);
00161 }
00162 
00163 void
00164 Directive::_set_follow_fields(BlockEntryStmt &entry,
00165                   BlockExitStmt &exit) {
00166     entry._follow = &exit;
00167     exit._follow = &entry;
00168 }
00169 
00170 static void
00171 dir_format_expression( String &s, Expression &e )
00172 {
00173     /// ...  Format the expression into a strstream.
00174 
00175     strstream    fmt_stream;
00176     fmt_stream << e << '\000';
00177 
00178     /// ...  Change the strstream into a String.
00179 
00180     char *data = fmt_stream.str();
00181     s = data;
00182 
00183     delete [] data;
00184 }
00185 
00186 static void
00187 dir_format_name( String &s, Expression &e )
00188 {
00189     /// ...  Format the expression into a strstream.
00190 
00191     strstream    fmt_stream;
00192     fmt_stream << e.base_variable_ref()->name_ref() << '\000';
00193 
00194     /// ...  Change the strstream into a String.
00195 
00196     char *data = fmt_stream.str();
00197     s = data;
00198 
00199     delete [] data;
00200 }
00201 
00202 static void
00203 dir_generate_expression_list( List<StringElem> &list,
00204                               const char *prefix, 
00205                               const char *sep, 
00206                               const char *postfix, 
00207                               Iterator<Expression> &iter )
00208 {
00209     String  s_format;
00210     String  s_prefix  = prefix;
00211     String  s_sep     = sep;
00212     String  s_postfix = postfix;
00213 
00214     int    max_len = 72 - s_postfix.len();
00215 
00216 
00217     while (iter.valid()) {
00218         if (iter.valid()) {
00219             strstream   o;
00220 
00221             o << s_prefix;        /// ...  Start with the 'prefix'
00222             dir_format_expression( s_format, iter.current() );
00223             o << s_format;        /// ...  dump the first expression.
00224 
00225             int length = s_prefix.len() + s_format.len();
00226 
00227             for ( ++iter; iter.valid(); ++iter) {
00228                 dir_format_expression( s_format, iter.current() );
00229 
00230                 if (length + s_sep.len() + s_format.len() >=  max_len) 
00231                     break;
00232 
00233                 o << s_sep << s_format;
00234                 length += s_sep.len() + s_format.len();
00235             }
00236 
00237             o << s_postfix << '\000';
00238 
00239             char *data = o.str();
00240 
00241             StringElem  *se = new StringElem( data );
00242 
00243             delete [] data;
00244 
00245             list.ins_last( se );
00246         }
00247     }
00248 }
00249 
00250 Boolean
00251 is_string_constant_expr (const Expression & expr)
00252 {
00253     if (expr.op() == STRING_CONSTANT_OP) {
00254     return True;
00255     } else {
00256     return False;
00257     }
00258 }
00259 
00260 /// Generate Directives from a List<Expression> 
00261 /// (and don't break lines for long directives)
00262 static void
00263 dir_generate_expression_list_quote_strings(List<StringElem> &list,
00264                        const char *prefix, 
00265                        const char *sep, 
00266                        const char *postfix, 
00267                        Iterator<Expression> &iter )
00268 {
00269     String  s_format;
00270     String  s_prefix  = prefix;
00271     String  s_sep     = sep;
00272     String  s_postfix = postfix;
00273 
00274     if (iter.valid()) {
00275     strstream   o;
00276     
00277     o << s_prefix;        /// ...  Start with the 'prefix'
00278 
00279     Expression *tempexpr = iter.current().clone();
00280     for (Traverser trav(*tempexpr, is_string_constant_expr);
00281          trav.valid();
00282          ++trav) {
00283 
00284         if (!trav.top_level()) {
00285         Assign<Expression> asexpr (trav.assign());
00286         Expression *expr = trav.pull();
00287         
00288         s_format = "'" + expr->str_data() + "'";
00289         
00290         asexpr = new StringConstExpr((const char *) s_format);
00291 
00292         } else {
00293         
00294         s_format = "'" + tempexpr->str_data() + "'";
00295         }
00296     }
00297     dir_format_expression (s_format, *tempexpr);
00298     o << s_format;
00299     delete tempexpr;
00300 
00301     for ( ++iter; iter.valid(); ++iter ) {
00302         Expression *tempexpr = iter.current().clone();
00303         for (Traverser trav(*tempexpr, is_string_constant_expr);
00304          trav.valid();
00305          ++trav) {
00306 
00307         if (!trav.top_level()) {
00308             Assign<Expression> asexpr (trav.assign());
00309             Expression *expr = trav.pull();
00310         
00311             s_format = "'" + expr->str_data() + "'";
00312         
00313             asexpr = new StringConstExpr((const char *) s_format);
00314 
00315         } else {
00316         
00317             s_format = "'" + tempexpr->str_data() + "'";
00318         }
00319         }
00320         dir_format_expression (s_format, *tempexpr);
00321         o << s_sep << s_format;
00322         delete tempexpr;
00323     }
00324 
00325     o << s_postfix << '\000';
00326 
00327     char *data = o.str();
00328 
00329     StringElem  *se = new StringElem( data );
00330 
00331     delete [] data;
00332 
00333     list.ins_last( se );
00334     }
00335 }
00336 
00337 
00338 static void
00339 dir_generate_expression_list_possibly_null( List<StringElem> &list,
00340                         const char *prefix, 
00341                         const char *sep, 
00342                         const char *postfix, 
00343                         Iterator<Expression> &iter )
00344 {
00345     String  s_prefix  = prefix;
00346     String  s_postfix = postfix;
00347 
00348     if (iter.valid()) {
00349     dir_generate_expression_list( list, prefix, sep, postfix, iter );
00350     } else {
00351     strstream o;
00352 
00353     o << s_prefix << s_postfix << '\000';
00354     
00355     char *data = o.str();
00356     
00357     StringElem  *se = new StringElem( data );
00358 
00359     delete [] data;
00360 
00361     list.ins_last( se );
00362     }
00363 }
00364 
00365 
00366 static void
00367 dir_generate_name_list( List<StringElem> &list,
00368             const char *prefix, 
00369             const char *sep, 
00370             const char *postfix, 
00371             Iterator<Expression> &iter )
00372 {
00373     String  s_format;
00374     String  s_prefix  = prefix;
00375     String  s_sep     = sep;
00376     String  s_postfix = postfix;
00377 
00378     int    max_len = 72 - s_postfix.len();
00379 
00380 
00381     while (iter.valid()) {
00382         if (iter.valid()) {
00383             strstream   o;
00384 
00385             o << s_prefix;        /// ...  Start with the 'prefix'
00386             dir_format_name( s_format, iter.current() );
00387             o << s_format;        /// ...  dump the first expression.
00388 
00389             int length = s_prefix.len() + s_format.len();
00390 
00391             for ( ++iter; iter.valid(); ++iter) {
00392                 dir_format_name( s_format, iter.current() );
00393 
00394                 if (length + s_sep.len() + s_format.len() >=  max_len) 
00395                     break;
00396 
00397                 o << s_sep << s_format;
00398                 length += s_sep.len() + s_format.len();
00399             }
00400 
00401             o << s_postfix << '\000';
00402 
00403             char *data = o.str();
00404 
00405             StringElem  *se = new StringElem( data );
00406 
00407             delete [] data;
00408 
00409             list.ins_last( se );
00410         }
00411     }
00412 }
00413 
00414 
00415 //------------------------------------------------------------------------
00416 
00417 void
00418 Directive::generate_convex_private_directive( Statement &s, Assertion &a )
00419 {
00420     p_assert( a.type() == AS_PRIVATE, "not a private assertion" );
00421 
00422     if (s.stmt_class() == BLOCK_ENTRY_STMT) {
00423         generate_csrd_private_directive( s, a );
00424         return;
00425     }
00426 
00427     AssertPrivate &ap = (AssertPrivate &) a;
00428 
00429     Iterator<Expression> iter = ap.arg_list_guarded();
00430 
00431     if (iter.valid()) {
00432         strstream   o;
00433 
00434         /// ...  The convex machine wants only Array names, so we must call 
00435         /// ...  the routine that prints only names
00436 
00437         dir_generate_name_list(text_list(), 
00438             "C$DIR DO_PRIVATE(", ", ", ")", iter);
00439 
00440         for (Mutator<StringElem> se_iter = text_list(); 
00441                                   se_iter.valid(); ++se_iter) {
00442             List<StringElem> &d 
00443                 = CASTAWAY(List<StringElem> &) s.pre_directives();
00444             d.ins_last( se_iter.grab() );
00445         }
00446     }
00447 }
00448 
00449 void
00450 Directive::generate_convex_reduction_directive( Statement &s, Assertion &a )
00451 {
00452     /// ...  No corresponding Convex directive!
00453     generate_csrd_reduction_directive( s, a );
00454 }
00455     
00456 
00457 void
00458 Directive::generate_convex_lastvalue_directive( Statement &s, Assertion &a )
00459 {
00460     /// ...  No corresponding Convex directive!
00461     generate_csrd_lastvalue_directive( s, a );
00462 }
00463 
00464 void
00465 Directive::generate_convex_prologue_directive( Statement &s, Assertion &a )
00466 {
00467     /// ...  No corresponding Convex directive!
00468     generate_csrd_prologue_directive( s, a );
00469 }
00470 
00471 void
00472 Directive::generate_convex_epilogue_directive( Statement &s, Assertion &a )
00473 {
00474     /// ...  No corresponding Convex directive!
00475     generate_csrd_epilogue_directive( s, a );
00476 }
00477 
00478 void
00479 Directive::generate_convex_serial_directive( Statement &s, Assertion &a )
00480 {
00481     p_assert( a.type() == AS_SERIAL, "not a serial assertion" );
00482 
00483     AssertSerial &ap = (AssertSerial &) a;
00484 
00485     Iterator<Expression> iter = ap.arg_list_guarded();
00486 
00487     if (! iter.valid()) {
00488         text_list().ins_last( new StringElem( "C$DIR NO_PARALLEL" ));
00489         text_list().ins_last( new StringElem( "C$DIR NO_VECTOR" ));
00490     }
00491     else {
00492         for ( ; iter.valid(); ++iter) {
00493             Expression & e = iter.current();
00494             if (e.op() == KEY_OP) {
00495                 if (e.str_data() == "NOVECTOR") 
00496                     text_list().ins_last( new StringElem("C$DIR NO_VECTOR"));
00497                 else if (e.str_data() == "NOPARALLEL") 
00498                     text_list().ins_last( new StringElem("C$DIR NO_PARALLEL"));
00499             }
00500         }
00501     }
00502 
00503     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
00504         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
00505         d.ins_last( s_iter.grab() );
00506     }
00507 }
00508 
00509 
00510 void
00511 Directive::generate_convex_parallel_directive( Statement &s, Assertion &a )
00512 {
00513     p_assert( a.type() == AS_PARALLEL, "not a parallel assertion" );
00514 
00515     AssertParallel &ap = (AssertParallel &) a;
00516 
00517     for (Iterator<Assertion> a_iter = ap.assertion_list(); 
00518                              a_iter.valid(); ++a_iter)
00519         if (a_iter.current().type() == AS_PROLOGUE)
00520             return;
00521 
00522     strstream   o;
00523 
00524     o << "C$DIR FORCE_PARALLEL" << '\0';
00525 
00526     char *data = o.str();
00527     StringElem  *se = new StringElem( data );
00528     delete data;
00529 
00530     text_list().ins_last( se );
00531 
00532     for (Mutator<StringElem> se_iter = text_list(); 
00533                               se_iter.valid(); ++se_iter) {
00534         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
00535         d.ins_first( se_iter.grab() );
00536     }
00537 }
00538 
00539 void
00540 Directive::generate_convex_directive( Statement &s )
00541 {
00542     if (_alist != 0) {
00543         for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
00544             switch (iter.current().type()) {
00545         case AS_OVERLAP:
00546         generate_csrd_overlap_directive( s, iter.current() );
00547         break;
00548         case AS_OVERLAP_SORT:
00549         generate_csrd_overlap_sort_directive( s, iter.current() );
00550         break;
00551         case AS_PRIVATE_DESCR:
00552         generate_csrd_private_descr_directive( s, iter.current() );
00553         break;
00554         case AS_TEST_MONOTONE:
00555         generate_csrd_test_monotone_directive( s, iter.current() );
00556         break;
00557         case AS_REDUCT_DESCR:
00558         generate_csrd_reduct_descr_directive( s, iter.current() );
00559         break;
00560         case AS_DEP_OVERLAP:
00561         generate_csrd_dep_overlap_directive( s, iter.current() );
00562         break;
00563         case AS_DEP_RO_RW:
00564         generate_csrd_dep_ROvsRW_directive( s, iter.current() );
00565         break;
00566         case AS_DEP_RW_WF:
00567         generate_csrd_dep_RWvsWF_directive( s, iter.current() );
00568         break;
00569         case AS_DEP_WF_RO:
00570         generate_csrd_dep_WFvsRO_directive( s, iter.current() );
00571         break;
00572         case AS_INSTRUMENT:
00573         break;
00574             case AS_PRIVATE:
00575                 generate_convex_private_directive( s, iter.current() );
00576                 break;
00577             case AS_SHARED:
00578                 generate_csrd_shared_directive( s, iter.current() );
00579                 break;
00580             case AS_RELATION:
00581                 generate_csrd_assert_directive( s, iter.current() );
00582                 break;
00583             case AS_SAFE_CONDITION:
00584                 generate_csrd_safe_condition_directive( s, iter.current() );
00585                 break;
00586             case AS_SERIAL:
00587                 generate_convex_serial_directive( s, iter.current() );
00588                 break;
00589             case AS_CRITICAL:
00590                 generate_csrd_critical_directive( s, iter.current() );
00591                 break;
00592             case AS_REDUCTION:
00593                 generate_convex_reduction_directive( s, iter.current() );
00594                 break;
00595             case AS_LASTVALUE:
00596                 generate_convex_lastvalue_directive( s, iter.current() );
00597                 break;
00598             case AS_DYNLASTVALUE:
00599                 generate_csrd_dynlastvalue_directive( s, iter.current() );
00600                 break;
00601         case AS_FIRSTVALUE:
00602         generate_csrd_firstvalue_directive( s, iter.current() );
00603         break;
00604         case AS_FORWARD:
00605         generate_csrd_forward_directive( s, iter.current() );
00606         break;
00607         case AS_RANGEWRITTEN:
00608         generate_csrd_rangewritten_directive( s, iter.current() );
00609         break;
00610             case AS_PROLOGUE:
00611                 generate_convex_prologue_directive( s, iter.current() );
00612                 break;
00613             case AS_EPILOGUE:
00614                 generate_convex_epilogue_directive( s, iter.current() );
00615                 break;
00616             case AS_PARALLEL:
00617                 generate_convex_parallel_directive( s, iter.current() );
00618                 break;
00619             case AS_COMMENT:
00620                 generate_comment_directive( s, iter.current() );
00621                 break;
00622             case AS_LOOPLABEL:
00623                 generate_csrd_looplabel_directive( s, iter.current() );
00624                 break;
00625         case AS_PRIVATEREFS:
00626         generate_csrd_privaterefs_directive( s, iter.current() );
00627         break;
00628         case AS_READONLYREFS:
00629         generate_csrd_readonlyrefs_directive( s, iter.current() );
00630         break;
00631         case AS_SHAREDREFS:
00632         generate_csrd_sharedrefs_directive( s, iter.current() );
00633         break;
00634         case AS_RTSHADOW:
00635         generate_csrd_rtshadow_directive( s, iter.current() );
00636         break;
00637         case AS_DEP_IO:
00638         generate_csrd_dep_io_directive( s, iter.current() );
00639         break;
00640         case AS_INLINE:
00641         generate_csrd_inline_directive( s, iter.current() );
00642         break;
00643         case AS_RECURSIVEINLINE:
00644         generate_csrd_recursive_inline_directive( s, iter.current() );
00645         break;
00646         case AS_NOINLINE:
00647         generate_csrd_noinline_directive( s, iter.current() );
00648         break;
00649         case AS_RUNTIMETEST:
00650         generate_csrd_runtimetest_directive( s, iter.current() );
00651         break;
00652         case AS_NODEPENDENCE:
00653         generate_csrd_nodependence_directive( s, iter.current() );
00654         break;
00655         case AS_SIDE_EFFECT_FREE:
00656         generate_csrd_sideeffectfree_directive( s, iter.current() );
00657         break;
00658         case AS_SCHEDULE:
00659         generate_csrd_schedule_directive( s, iter.current() );
00660         break;
00661         case AS_PREAMBLE:
00662         case AS_POSTAMBLE:
00663         break;
00664         case AS_MAYMOD:
00665         generate_csrd_maymod_directive( s, iter.current() );
00666         break;
00667         case AS_NOMOD:
00668         generate_csrd_nomod_directive( s, iter.current() );
00669         break;
00670         case AS_RECURRENCE:
00671                 generate_recurrence_directive( s, iter.current() );
00672             break;
00673             default:
00674                 p_abort( "unknown CONVEX assertion type" );
00675                 break;
00676             }
00677         }
00678     }
00679 }
00680 
00681 //------------------------------------------------------------------------
00682 
00683 void
00684 Directive::generate_convex_spp_private_directive( Statement &s, Assertion &a )
00685 {
00686     p_assert( a.type() == AS_PRIVATE, "not a private assertion" );
00687 
00688     if (s.stmt_class() == BLOCK_ENTRY_STMT) {
00689         generate_csrd_private_directive( s, a );
00690         return;
00691     }
00692 
00693     AssertPrivate &ap = (AssertPrivate &) a;
00694 
00695     Iterator<Expression> iter = ap.arg_list_guarded();
00696 
00697     if (iter.valid()) {
00698         strstream   o;
00699 
00700         /// ...  The convex machine wants only Array names, in order to enforce
00701         /// ...  thi it should run with the array section privatization turned
00702         /// ...  off, and the routine that prints only names should be called
00703 
00704         dir_generate_name_list(text_list(), 
00705             "C$DIR LOOP_PRIVATE(", ", ", ")", iter);
00706 
00707         for (Mutator<StringElem> se_iter = text_list(); 
00708                                   se_iter.valid(); ++se_iter) {
00709             List<StringElem> &d 
00710                 = CASTAWAY(List<StringElem> &) s.pre_directives();
00711             d.ins_last( se_iter.grab() );
00712         }
00713     }
00714 }
00715 
00716 void
00717 Directive::generate_convex_spp_critical_directive( Statement &s, Assertion &a )
00718 {
00719     p_assert( a.type() == AS_CRITICAL, "not a critical assertion" );
00720 
00721     if (s.stmt_class() == BLOCK_ENTRY_STMT) {
00722         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
00723         d.ins_last( new StringElem( "C$DIR CRITICAL_SECTION" ));
00724         return;
00725     }
00726     else if (s.stmt_class() == BLOCK_EXIT_STMT) {
00727         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
00728         d.ins_last( new StringElem( "C$DIR END_CRITICAL_SECTION" ));
00729         return;
00730     }
00731 
00732     List<StringElem> &da = CASTAWAY(List<StringElem> &) s.pre_directives();
00733     da.ins_last( new StringElem( "C$DIR CRITICAL_SECTION" ));
00734 
00735     List<StringElem> &db = CASTAWAY(List<StringElem> &) s.post_directives();
00736     db.ins_last( new StringElem( "C$DIR END_CRITICAL_SECTION" ));
00737 }
00738 
00739 String 
00740 directive_get_sym_name( Expression &exp ) {
00741 
00742     String ret_str;
00743     switch ( exp.op() ) {
00744 
00745     default:  
00746         cerr << "directive_get_sym_name: exp = "; exp.print( cerr ); cerr << endl;
00747         p_abort( "directive_get_sym_name: exp is not ID or ARRAY_REF expr" );
00748         break;
00749 
00750     case ID_OP: 
00751         ret_str = exp.symbol().name_ref();
00752         break;
00753 
00754     case ARRAY_REF_OP: 
00755         ret_str = exp.array().symbol().name_ref();
00756         break;
00757     }
00758     return ret_str;
00759 }
00760     
00761 void
00762 Directive::generate_convex_spp_reduction_directive( Statement &s, Assertion &a )
00763 {
00764     /// ...  No corresponding Convex directive!
00765     /// ...  generate_csrd_reduction_directive( s, a );
00766 
00767     /// ...  Convex SPP has enabled put whole array into reduction assertion
00768 
00769     p_assert( a.type() == AS_REDUCTION, "not a private assertion" );
00770 
00771     if (s.stmt_class() == BLOCK_ENTRY_STMT) {
00772         generate_csrd_private_directive( s, a );
00773         return;
00774     }
00775 
00776     RefSet<Expression> reducts;
00777 
00778     if (a.arg_list_valid()) {
00779 
00780     for (Iterator<Expression> iter = a.arg_list_guarded();
00781          iter.valid();
00782          ++iter)
00783         {
00784         reducts.ins(iter.current());
00785         }
00786     }
00787 
00788     strstream   o;
00789 
00790     if (reducts.entries() > 0) {
00791         o << "C$DIR REDUCTION(";
00792         Iterator<Expression> iter=reducts;
00793 
00794     /// ...  First iteration peeled
00795         if (iter.valid()) {
00796             o << directive_get_sym_name( iter.current() );
00797             ++iter;
00798         }
00799         for (;
00800             iter.valid();
00801              ++iter)
00802             {
00803                 o << ",";
00804                 o << directive_get_sym_name( iter.current() );
00805             }
00806         o << ")\n";
00807     }
00808 }
00809 
00810 
00811 void
00812 Directive::generate_convex_spp_lastvalue_directive( Statement &s, Assertion &a )
00813 {
00814     p_assert( a.type() == AS_LASTVALUE, "not a last value assertion" );
00815 
00816     text_list().ins_last( new StringElem( "C$DIR SAVE_LAST" ));
00817 
00818     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
00819         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
00820         d.ins_last( s_iter.grab() );
00821     }
00822 }
00823 
00824 void
00825 Directive::generate_convex_spp_serial_directive( Statement &s, Assertion &a )
00826 {
00827     p_assert( a.type() == AS_SERIAL, "not a serial assertion" );
00828 
00829     AssertSerial &ap = (AssertSerial &) a;
00830 
00831     Iterator<Expression> iter = ap.arg_list_guarded();
00832 
00833     if (! iter.valid()) {
00834         text_list().ins_last( new StringElem( "C$DIR NO_PARALLEL" ));
00835     }
00836     else {
00837         for ( ; iter.valid(); ++iter) {
00838             Expression & e = iter.current();
00839             if (e.op() == KEY_OP) {
00840                 if (e.str_data() == "NOPARALLEL") 
00841                     text_list().ins_last( new StringElem("C$DIR NO_PARALLEL"));
00842             }
00843         }
00844     }
00845 
00846     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
00847         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
00848         d.ins_last( s_iter.grab() );
00849     }
00850 }
00851 
00852 
00853 void
00854 Directive::generate_convex_spp_parallel_directive( Statement &s, Assertion &a )
00855 {
00856     p_assert( a.type() == AS_PARALLEL, "not a parallel assertion" );
00857 
00858     AssertParallel &ap = (AssertParallel &) a;
00859 
00860     for (Iterator<Assertion> a_iter = ap.assertion_list(); 
00861                              a_iter.valid(); ++a_iter)
00862         if (a_iter.current().type() == AS_PROLOGUE)
00863             return;
00864 
00865     StringElem  *se = new StringElem( "C$DIR LOOP_PARALLEL" );
00866     text_list().ins_last( se );
00867 
00868     for (Mutator<StringElem> se_iter = text_list(); 
00869                               se_iter.valid(); ++se_iter) {
00870         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
00871         d.ins_first( se_iter.grab() );
00872     }
00873 }
00874 
00875 void
00876 Directive::generate_convex_spp_nodependence_directive( Statement &s, Assertion &a )
00877 {
00878     p_assert( a.type() == AS_NODEPENDENCE, "not a NO_DEPENDENCE assertion" );
00879  
00880     AssertNoDependence &ap = (AssertNoDependence &) a;
00881     
00882     Iterator<Expression> iter = ap.arg_list_guarded();
00883  
00884     dir_generate_name_list(text_list(), "C$DIR NO_LOOP_DEPENDENCE ( ", ", ", " )", iter);
00885  
00886     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
00887     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
00888     d.ins_last( s_iter.grab() );
00889     }
00890 }
00891 
00892 void
00893 Directive::generate_convex_spp_directive( Statement &s )
00894 {
00895     if (_alist != 0) {
00896         for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
00897             switch (iter.current().type()) {
00898         case AS_OVERLAP:
00899         generate_csrd_overlap_directive( s, iter.current() );
00900         break;
00901         case AS_OVERLAP_SORT:
00902         generate_csrd_overlap_sort_directive( s, iter.current() );
00903         break;
00904         case AS_PRIVATE_DESCR:
00905         generate_csrd_private_descr_directive( s, iter.current() );
00906         break;
00907         case AS_TEST_MONOTONE:
00908         generate_csrd_test_monotone_directive( s, iter.current() );
00909         break;
00910         case AS_REDUCT_DESCR:
00911         generate_csrd_reduct_descr_directive( s, iter.current() );
00912         break;
00913         case AS_DEP_OVERLAP:
00914         generate_csrd_dep_overlap_directive( s, iter.current() );
00915         break;
00916         case AS_DEP_RO_RW:
00917         generate_csrd_dep_ROvsRW_directive( s, iter.current() );
00918         break;
00919         case AS_DEP_RW_WF:
00920         generate_csrd_dep_RWvsWF_directive( s, iter.current() );
00921         break;
00922         case AS_DEP_WF_RO:
00923         generate_csrd_dep_WFvsRO_directive( s, iter.current() );
00924         break;
00925             case AS_PRIVATE:
00926                 generate_convex_spp_private_directive( s, iter.current() );
00927                 break;
00928             case AS_SHARED:
00929                 generate_csrd_shared_directive( s, iter.current() );
00930                 break;
00931             case AS_RELATION:
00932                 generate_csrd_assert_directive( s, iter.current() );
00933                 break;
00934             case AS_SAFE_CONDITION:
00935                 generate_csrd_safe_condition_directive( s, iter.current() );
00936                 break;
00937             case AS_SERIAL:
00938                 generate_convex_spp_serial_directive( s, iter.current() );
00939                 break;
00940             case AS_CRITICAL:
00941                 generate_convex_spp_critical_directive( s, iter.current() );
00942                 break;
00943             case AS_REDUCTION:
00944                 generate_convex_spp_reduction_directive( s, iter.current() );
00945                 break;
00946             case AS_LASTVALUE:
00947                 generate_convex_spp_lastvalue_directive( s, iter.current() );
00948                 break;
00949             case AS_DYNLASTVALUE:
00950                 generate_csrd_dynlastvalue_directive( s, iter.current() );
00951                 break;
00952         case AS_FIRSTVALUE:
00953         generate_csrd_firstvalue_directive( s, iter.current() );
00954         break;
00955         case AS_FORWARD:
00956         generate_csrd_forward_directive( s, iter.current() );
00957         break;
00958         case AS_RANGEWRITTEN:
00959         generate_csrd_rangewritten_directive( s, iter.current() );
00960         break;
00961             case AS_PROLOGUE:
00962                 generate_csrd_prologue_directive( s, iter.current() );
00963                 break;
00964             case AS_EPILOGUE:
00965                 generate_csrd_epilogue_directive( s, iter.current() );
00966                 break;
00967             case AS_PARALLEL:
00968                 generate_convex_spp_parallel_directive( s, iter.current() );
00969                 break;
00970              case AS_PARCONDITION:
00971                 generate_csrd_parcondition_directive( s, iter.current() );
00972         break;
00973             case AS_COMMENT:
00974                 generate_comment_directive( s, iter.current() );
00975                 break;
00976             case AS_LOOPLABEL:
00977                 generate_csrd_looplabel_directive( s, iter.current() );
00978                 break;
00979         case AS_NODEPENDENCE:
00980         generate_convex_spp_nodependence_directive( s, iter.current() );
00981         break;
00982         case AS_INSTRUMENT:
00983         break;
00984             case AS_INDUCTION:
00985                 generate_csrd_induction_directive( s, iter.current() );
00986                 break;
00987         case AS_DEP_IO:
00988         generate_csrd_dep_io_directive(s, iter.current() );
00989         break;
00990         case AS_RECURRENCE:
00991                 generate_recurrence_directive( s, iter.current() );
00992         break;
00993         case AS_PRIVATEREFS:
00994         case AS_READONLYREFS:
00995         case AS_SHAREDREFS:
00996         case AS_INLINE:
00997         case AS_RECURSIVEINLINE:
00998         case AS_NOINLINE:
00999         case AS_RUNTIMETEST:
01000         case AS_SIDE_EFFECT_FREE:
01001         case AS_SCHEDULE:
01002         case AS_PREAMBLE:
01003         case AS_POSTAMBLE:
01004         case AS_MAYMOD:
01005         case AS_NOMOD:
01006             case 101:
01007         break;
01008             default:
01009                 p_abort( "unknown CONVEX SPP assertion type");
01010                 break;
01011             }
01012         }
01013     }
01014 }
01015 
01016 //------------------------------------------------------------------------
01017 
01018 static void
01019 dir_generate_string_list( List<StringElem> &list,
01020                           const char *prefix,
01021                           Iterator<StringElem> &iter )
01022 {
01023 ///    const int max_len = 72;
01024 
01025     for ( ; iter.valid(); ++iter) {
01026         String s = prefix;
01027         s += iter.current();
01028         StringElem  *se = new StringElem( s );
01029         list.ins_last( se );
01030     }
01031 }
01032 
01033 void
01034 Directive::generate_comment_directive( Statement &s, Assertion &a )
01035 {
01036     p_assert( a.type() == AS_COMMENT, "not a comment" );
01037 
01038     AssertComment &ap = (AssertComment &) a;
01039 
01040     Iterator<StringElem> iter = ap.string_arg_list_guarded();
01041 
01042     dir_generate_string_list( text_list(), "C", iter );
01043 
01044     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01045         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01046         d.ins_last( s_iter.grab() );
01047     }
01048 }
01049 
01050 void
01051 Directive::generate_recurrence_directive( Statement &s, Assertion &a )
01052 {
01053     p_assert( a.type() == AS_RECURRENCE, "not a recurrence" );
01054 
01055     RecurrenceAssertion &ap = (RecurrenceAssertion &) a;
01056 
01057     Iterator<StringElem> iter = ap.ra_string_arg_list_guarded();
01058 
01059     dir_generate_string_list( text_list(), "", iter );
01060 
01061     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01062         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01063         d.ins_last( s_iter.grab() );
01064     }
01065 }
01066 
01067 void
01068 Directive::generate_csrd_instrument_directive( Statement &s, Assertion &a )
01069 {
01070     p_assert( a.type() == AS_INSTRUMENT, "not an instrument assertion" );
01071 
01072     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01073     d.ins_last( new StringElem( "CSRD$ INSTRUMENT" ));
01074 }
01075 
01076 void
01077 Directive::generate_csrd_rtshadow_directive( Statement &s, Assertion &a )
01078 {
01079     p_assert( a.type() == AS_RTSHADOW, "not an RTShadow assertion" );
01080 
01081     AssertPrivate &ap = (AssertPrivate &) a;
01082 
01083     Iterator<Expression> iter = ap.arg_list_guarded();
01084 
01085     dir_generate_expression_list(text_list(), "CSRD$ RTSHADOW ", ", ", "", iter);
01086 
01087     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01088         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01089         d.ins_last( s_iter.grab() );
01090     }
01091 }
01092 
01093 void
01094 Directive::generate_csrd_dep_io_directive( Statement &s, Assertion &a )
01095 {
01096     p_assert( a.type() == AS_DEP_IO, "not a I/O dependence assertion" );
01097 
01098     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01099     d.ins_last( new StringElem( "CSRD$ DEP_IO" ));
01100 }
01101 
01102 void
01103 Directive::generate_csrd_inline_directive( Statement &s, Assertion &a )
01104 {
01105     p_assert( a.type() == AS_INLINE, "not an inline assertion" );
01106 
01107     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01108     d.ins_last( new StringElem( "CSRD$ INLINE" ));
01109 }
01110 
01111 void
01112 Directive::generate_csrd_recursive_inline_directive( Statement &s, Assertion &a )
01113 {
01114     p_assert( a.type() == AS_RECURSIVEINLINE, "not a recursive inline assertion" );
01115 
01116     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01117     d.ins_last( new StringElem( "CSRD$ RECURSIVE INLINE" ));
01118 }
01119 
01120 void
01121 Directive::generate_csrd_noinline_directive( Statement &s, Assertion &a )
01122 {
01123     p_assert( a.type() == AS_NOINLINE, "not a noinline assertion" );
01124 
01125     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01126     d.ins_last( new StringElem( "CSRD$ NO INLINE" ));
01127 }
01128 
01129 void
01130 Directive::generate_csrd_noputget_directive( Statement &s, Assertion &a )
01131 {
01132     p_assert( a.type() == AS_NOPUTGET, "not a noinline assertion" );
01133 
01134     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01135     d.ins_last( new StringElem( "CSRD$ NO PUTGET" ));
01136 }
01137 
01138 void
01139 Directive::generate_csrd_preamble_directive( Statement &s, Assertion &a )
01140 {
01141     p_assert( a.type() == AS_PREAMBLE, "not a preamble assertion" );
01142 
01143     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01144     d.ins_last( new StringElem( "CSRD$ PREAMBLE" ));
01145 }
01146 
01147 void
01148 Directive::generate_csrd_postamble_directive( Statement &s, Assertion &a )
01149 {
01150     p_assert( a.type() == AS_POSTAMBLE, "not a postamble assertion" );
01151 
01152     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01153     d.ins_last( new StringElem( "CSRD$ POSTAMBLE" ));
01154 }
01155 
01156 void
01157 Directive::generate_csrd_runtimetest_directive( Statement &s, Assertion &a )
01158 {
01159     p_assert( a.type() == AS_RUNTIMETEST, "not a run-time-test assertion" );
01160 
01161     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01162     d.ins_last( new StringElem( "CSRD$ RUN_TIME_TEST" ));
01163 }
01164 
01165 void
01166 Directive::generate_csrd_looplabel_directive( Statement &s, Assertion &a )
01167 {
01168     p_assert( a.type() == AS_LOOPLABEL, "not a loop label assertion" );
01169 
01170     AssertLoopLabel &al = (AssertLoopLabel &) a;
01171 
01172     /// ...  Put quotes around the string
01173 
01174     if (al.string_arg_list_valid()) {
01175     String arg_string = (String )"CSRD$ LOOPLABEL '" + al.string_arg_list_guarded()[0] + "'";
01176     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01177     d.ins_last( new StringElem(arg_string));
01178     }
01179 }
01180 
01181 void
01182 Directive::generate_csrd_nodependence_directive( Statement &s, Assertion &a )
01183 {
01184     p_assert( a.type() == AS_NODEPENDENCE, "not a NO_DEPENDENCE assertion" );
01185  
01186     AssertNoDependence &ap = (AssertNoDependence &) a;
01187     
01188     Iterator<Expression> iter = ap.arg_list_guarded();
01189  
01190     dir_generate_expression_list(text_list(), "CSRD$ NO_DEPENDENCE ( ", ", ", " )", iter);
01191  
01192     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01193     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01194     d.ins_last( s_iter.grab() );
01195     }
01196 }
01197  
01198 void
01199 Directive::generate_csrd_sideeffectfree_directive( Statement &s, Assertion &a )
01200 {
01201     p_assert( a.type() == AS_SIDE_EFFECT_FREE, "not a SIDE_EFFECT_FREE assertion" );
01202 
01203     AssertSideEffectFree &ap = (AssertSideEffectFree &) a;
01204 
01205     Iterator<Expression> iter = ap.arg_list_guarded();
01206 
01207     dir_generate_expression_list(text_list(), "CSRD$ SIDE_EFFECT_FREE ( ", ", ", " )", iter);
01208 
01209     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01210         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01211         d.ins_last( s_iter.grab() );
01212     }
01213 }
01214 
01215 void
01216 Directive::generate_csrd_private_directive( Statement &s, Assertion &a )
01217 {
01218     p_assert( a.type() == AS_PRIVATE, "not a private assertion" );
01219 
01220     AssertPrivate &ap = (AssertPrivate &) a;
01221 
01222     Iterator<Expression> iter = ap.arg_list_guarded();
01223 
01224     dir_generate_expression_list(text_list(), "CSRD$ PRIVATE ", ", ", "", iter);
01225 
01226     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01227         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01228         d.ins_last( s_iter.grab() );
01229     }
01230 }
01231 
01232 void
01233 Directive::generate_csrd_privaterefs_directive( Statement &s, Assertion &a )
01234 {
01235     if (switch_value("memory_dirs") == 0)
01236     return;
01237     
01238     p_assert( a.type() == AS_PRIVATEREFS, "not a PrivateRefs assertion" );
01239 
01240     AssertPrivateRefs &ap = (AssertPrivateRefs &) a;
01241 
01242     Iterator<Expression> iter = ap.arg_list_guarded();
01243 
01244     dir_generate_expression_list_quote_strings(text_list(), "CSRD$ PRIVATE_REFS ", ", ", "", iter);
01245 
01246     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01247         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01248         d.ins_last( s_iter.grab() );
01249     }
01250 }
01251 
01252 void
01253 Directive::generate_csrd_readonlyrefs_directive( Statement &s, Assertion &a )
01254 {
01255     if (switch_value("memory_dirs") == 0)
01256     return;
01257     
01258     p_assert( a.type() == AS_READONLYREFS, "not a ReadOnlyRefs assertion" );
01259 
01260     AssertReadOnlyRefs &ap = (AssertReadOnlyRefs &) a;
01261 
01262     Iterator<Expression> iter = ap.arg_list_guarded();
01263 
01264     dir_generate_expression_list_quote_strings(text_list(), "CSRD$ READ_ONLY_REFS ", ", ", "", iter);
01265 
01266     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01267         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01268         d.ins_last( s_iter.grab() );
01269     }
01270 }
01271 
01272 void
01273 Directive::generate_csrd_sharedrefs_directive( Statement &s, Assertion &a )
01274 {
01275     if (switch_value("memory_dirs") == 0)
01276     return;
01277     
01278     p_assert( a.type() == AS_SHAREDREFS, "not a SharedRefs assertion" );
01279 
01280     AssertSharedRefs &ap = (AssertSharedRefs &) a;
01281 
01282     Iterator<Expression> iter = ap.arg_list_guarded();
01283 
01284     dir_generate_expression_list(text_list(), "CSRD$ SHARED_REFS ", ", ", "", iter);
01285 
01286     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01287         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01288         d.ins_last( s_iter.grab() );
01289     }
01290 }
01291 
01292 void
01293 Directive::generate_csrd_shared_directive( Statement &s, Assertion &a )
01294 {
01295     p_assert( a.type() == AS_SHARED, "not a shared assertion" );
01296 
01297     AssertShared &ap = (AssertShared &) a;
01298 
01299     Iterator<Expression> iter = ap.arg_list_guarded();
01300 
01301     dir_generate_expression_list(text_list(), "CSRD$ SHARED ", ", ", "", iter);
01302 
01303     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01304         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01305         d.ins_last( s_iter.grab() );
01306     }
01307 }
01308 
01309 void
01310 Directive::generate_csrd_induction_directive( Statement &s, Assertion &a )
01311 {
01312     p_assert( a.type() == AS_INDUCTION, "not a induction assertion" );
01313 
01314     AssertInduction &ap = (AssertInduction &) a;
01315 
01316     Iterator<Expression> iter = ap.arg_list_guarded();
01317 
01318     Expression & expr = iter.current();
01319 
01320     if (expr.op() == COMMA_OP) {
01321     Iterator<Expression> eiter = expr.arg_list();
01322     dir_generate_expression_list_quote_strings
01323         (text_list(), "CSRD$ INDUCTION ", ", ", "", eiter);
01324     } else {
01325     dir_generate_expression_list(text_list(), "CSRD$ INDUCTION ", ", ", "", iter);
01326     }
01327 
01328     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01329         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01330         d.ins_last( s_iter.grab() );
01331     }
01332 }
01333 
01334 
01335 void
01336 Directive::generate_csrd_parcondition_directive( Statement &s, Assertion &a )
01337 {
01338     p_assert( a.type() == AS_PARCONDITION, "not a parallel condition assertion" );
01339 
01340     AssertParallelCondition &ap = (AssertParallelCondition &) a;
01341 
01342     Iterator<Expression> iter = ap.arg_list_guarded();
01343 
01344     dir_generate_expression_list(text_list(), "CSRD$ PARALLEL CONDITION ", ", ", "", iter);
01345 
01346 
01347     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01348         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01349         d.ins_last( s_iter.grab() );
01350     }
01351 }
01352 
01353 
01354 void
01355 Directive::generate_csrd_maymod_directive( Statement &s, Assertion &a )
01356 {
01357     p_assert( a.type() == AS_MAYMOD, "not a may-mod assertion" );
01358 
01359     AssertMayMod &ap = (AssertMayMod &) a;
01360 
01361     Iterator<Expression> iter = ap.arg_list_guarded();
01362 
01363     dir_generate_expression_list_possibly_null(text_list(), "CSRD$ MAYMOD ", ", ", "", iter);
01364 
01365     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01366         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01367         d.ins_last( s_iter.grab() );
01368     }
01369 }
01370 void
01371 Directive::generate_csrd_nomod_directive( Statement &s, Assertion &a )
01372 {
01373     p_assert( a.type() == AS_NOMOD, "not a no-mod assertion" );
01374 
01375     AssertNoMod &ap = (AssertNoMod &) a;
01376 
01377     Iterator<Expression> iter = ap.arg_list_guarded();
01378 
01379     dir_generate_expression_list_possibly_null(text_list(), "CSRD$ NOMOD ", ", ", "", iter);
01380 
01381     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01382         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01383         d.ins_last( s_iter.grab() );
01384     }
01385 }
01386 
01387 
01388 void
01389 Directive::generate_csrd_assert_directive( Statement &s, Assertion &a )
01390 {
01391     p_assert( a.type() == AS_RELATION, "not a relation assertion" );
01392 
01393     AssertRelation &ap = (AssertRelation &) a;
01394 
01395     Iterator<Expression> iter = ap.arg_list_guarded();
01396 
01397     dir_generate_expression_list(text_list(), "CSRD$ ASSERT ", ", ", "", iter);
01398 
01399     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01400         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01401         d.ins_last( s_iter.grab() );
01402     }
01403 }
01404 
01405 void
01406 Directive::generate_csrd_safe_condition_directive( Statement &s, Assertion &a )
01407 {
01408     p_assert( a.type() == AS_SAFE_CONDITION, "not a safe_condition assertion" );
01409 
01410     AssertSafeCondition &ap = (AssertSafeCondition &) a;
01411 
01412     Iterator<Expression> iter = ap.arg_list_guarded();
01413 
01414     dir_generate_expression_list(text_list(), "CSRD$ SAFE_CONDITION ", ", ", "", iter);
01415 
01416     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01417         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01418         d.ins_last( s_iter.grab() );
01419     }
01420 }
01421 
01422 void
01423 Directive::generate_csrd_serial_directive( Statement &s, Assertion &a )
01424 {
01425     p_assert( a.type() == AS_SERIAL, "not a serial assertion" );
01426 
01427     /// ...     AssertSerial &ap = (AssertSerial &) a;
01428 
01429 /// Ignore any arg_list for the assertion, since a CSRD SERIAL directive
01430 /// does not need any arguments.
01431 
01432     text_list().ins_last( new StringElem( "CSRD$ SERIAL" ));
01433 
01434     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01435         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01436         d.ins_last( s_iter.grab() );
01437     }
01438 }
01439 
01440 void
01441 Directive::generate_csrd_critical_directive( Statement &s, Assertion &a )
01442 {
01443     p_assert( a.type() == AS_CRITICAL, "not a critical assertion" );
01444 
01445 #if 1
01446     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01447     d.ins_last( new StringElem( "CSRD$ CRITICAL" ));
01448 #else
01449     AssertCritical &ap = (AssertCritical &) a;
01450 
01451     Iterator<Expression> iter = ap.arg_list_guarded();
01452 
01453     dir_generate_expression_list(text_list(),"CSRD$ CRITICAL ",", ","",iter);
01454 
01455     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01456         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01457         d.ins_last( s_iter.grab() );
01458     }
01459 #endif
01460 }
01461 
01462 void
01463 Directive::generate_csrd_reduction_directive( Statement &s, Assertion &a )
01464 {
01465     p_assert( a.type() == AS_REDUCTION, "not a reduction assertion" );
01466 
01467     AssertReduction &ap = (AssertReduction &) a;
01468 
01469     Iterator<Expression> iter = ap.arg_list_guarded();
01470 
01471     dir_generate_expression_list(text_list(),"CSRD$ REDUCTION ",", ","",iter);
01472 
01473     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01474         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01475         d.ins_last( s_iter.grab() );
01476     }
01477 }
01478 
01479 void
01480 Directive::generate_csrd_lastvalue_directive( Statement &s, Assertion &a )
01481 {
01482     p_assert( a.type() == AS_LASTVALUE, "not a lastvalue assertion" );
01483 
01484     AssertLastValue &ap = (AssertLastValue &) a;
01485 
01486     Iterator<Expression> iter = ap.arg_list_guarded();
01487 
01488     dir_generate_expression_list(text_list(),"CSRD$ LASTVALUE ",", ","",iter);
01489 
01490     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01491         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01492         d.ins_last( s_iter.grab() );
01493     }
01494 }
01495 
01496 void
01497 Directive::generate_csrd_dynlastvalue_directive( Statement &s, Assertion &a )
01498 {
01499     p_assert( a.type() == AS_DYNLASTVALUE, "not a dynamic lastvalue assertion" );
01500 
01501     AssertDynLastValue &ap = (AssertDynLastValue &) a;
01502 
01503     Iterator<Expression> iter = ap.arg_list_guarded();
01504 
01505     dir_generate_expression_list(text_list(),"CSRD$ DYNLASTVALUE ",", ","",iter);
01506 
01507     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01508         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01509         d.ins_last( s_iter.grab() );
01510     }
01511 }
01512 
01513 void
01514 Directive::generate_csrd_firstvalue_directive( Statement &s, Assertion &a )
01515 {
01516     p_assert( a.type() == AS_FIRSTVALUE, "not a firstvalue assertion" );
01517 
01518     AssertFirstValue &ap = (AssertFirstValue &) a;
01519 
01520     Iterator<Expression> iter = ap.arg_list_guarded();
01521 
01522     dir_generate_expression_list(text_list(),"CSRD$ FIRSTVALUE ",", ","",iter);
01523 
01524     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01525         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01526         d.ins_last( s_iter.grab() );
01527     }
01528 }
01529 
01530 void
01531 Directive::generate_csrd_forward_directive( Statement &s, Assertion &a )
01532 {
01533     p_assert( a.type() == AS_FORWARD, "not a forward assertion" );
01534 
01535     AssertForward &ap = (AssertForward &) a;
01536 
01537     Iterator<Expression> iter = ap.arg_list_guarded();
01538 
01539     dir_generate_expression_list(text_list(),"CSRD$ FORWARD ",", ","",iter);
01540 
01541     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01542         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01543         d.ins_last( s_iter.grab() );
01544     }
01545 }
01546 
01547 void
01548 Directive::generate_csrd_rangewritten_directive( Statement &s, Assertion &a )
01549 {
01550     p_assert( a.type() == AS_RANGEWRITTEN, "not a rangewritten assertion" );
01551 
01552     AssertRangeWritten &ap = (AssertRangeWritten &) a;
01553 
01554     Iterator<Expression> iter = ap.arg_list_guarded();
01555 
01556     dir_generate_expression_list(text_list(),"CSRD$ RANGE WRITTEN ",", ","",iter);
01557 
01558     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
01559         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
01560         d.ins_last( s_iter.grab() );
01561     }
01562 }
01563 
01564 void
01565 Directive::generate_csrd_prologue_directive( Statement &s, Assertion &a )
01566 {
01567     p_assert( a.type() == AS_PROLOGUE, "not a prologue assertion" );
01568 
01569     AssertPrologue &ap = (AssertPrologue &) a;
01570 
01571     Iterator<Expression> iter = ap.arg_list_guarded();
01572 
01573     if (iter.valid()) {
01574         strstream   o;
01575 
01576         o << "CSRD$ BEGIN PARALLEL (";
01577         o << iter.current();
01578         o << ")";
01579         o << '\0';
01580 
01581         char *data = o.str();
01582         StringElem  *se = new StringElem( data );
01583         delete data;
01584 
01585         text_list().ins_last( se );
01586 
01587         for (Mutator<StringElem> se_iter = text_list(); 
01588                                   se_iter.valid(); ++se_iter) {
01589             List<StringElem> &d 
01590                 = CASTAWAY(List<StringElem> &) s.pre_directives();
01591             d.ins_last( se_iter.grab() );
01592         }
01593     }
01594 }
01595 
01596 void
01597 Directive::generate_csrd_schedule_directive( Statement &s, Assertion &a )
01598 {
01599     p_assert( a.type() == AS_SCHEDULE, "not a schedule assertion" );
01600 
01601     AssertSchedule &al = (AssertSchedule &) a;
01602 
01603     /// ...  Put quotes around the string
01604 
01605     if (al.string_arg_list_valid()) {
01606     String arg_string = (String )"CSRD$ SCHEDULE '" + al.string_arg_list_guarded()[0] + "'";
01607     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01608     d.ins_last( new StringElem(arg_string));
01609     }
01610 }
01611 
01612 void
01613 Directive::generate_csrd_epilogue_directive( Statement &s, Assertion &a )
01614 {
01615     p_assert( a.type() == AS_EPILOGUE, "not an epilogue assertion" );
01616 
01617     AssertEpilogue &ap = (AssertEpilogue &) a;
01618 
01619     Iterator<Expression> iter = ap.arg_list_guarded();
01620 
01621     if (iter.valid()) {
01622         strstream   o;
01623 
01624         o << "CSRD$ END PARALLEL (";
01625         o << iter.current();
01626         o << ")";
01627         o << '\0';
01628 
01629         char *data = o.str();
01630         StringElem  *se = new StringElem( data );
01631         delete data;
01632 
01633         text_list().ins_last( se );
01634 
01635         for (Mutator<StringElem> se_iter = text_list(); 
01636                                   se_iter.valid(); ++se_iter) {
01637             List<StringElem> &d 
01638                 = CASTAWAY(List<StringElem> &) s.post_directives();
01639             d.ins_last( se_iter.grab() );
01640         }
01641     }
01642 }
01643 
01644 void
01645 Directive::generate_csrd_parallel_directive( Statement &s, Assertion &a )
01646 {
01647     p_assert( a.type() == AS_PARALLEL, "not a parallel assertion" );
01648 
01649     AssertParallel &ap = (AssertParallel &) a;
01650 
01651     for (Iterator<Assertion> a_iter = ap.assertion_list(); 
01652                              a_iter.valid(); ++a_iter)
01653         if (a_iter.current().type() == AS_PROLOGUE)
01654             return;
01655 
01656     strstream   o;
01657 
01658     o << "CSRD$ PARALLEL ";
01659 
01660     if (s.stmt_class() == DO_STMT) {
01661     o << "(";
01662     Iterator<Expression> iter = ap.arg_list_guarded();
01663     
01664     if (iter.valid()) 
01665         o << iter.current();
01666     else
01667         o << s.index();
01668     
01669     o << ")";
01670     }
01671     o << '\0';
01672 
01673     char *data = o.str();
01674     StringElem  *se = new StringElem( data );
01675     delete data;
01676 
01677     text_list().ins_last( se );
01678 
01679     for (Mutator<StringElem> se_iter = text_list(); 
01680                               se_iter.valid(); ++se_iter) {
01681         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
01682         d.ins_first( se_iter.grab() );
01683     }
01684 }
01685 
01686 void
01687 Directive::generate_csrd_directive( Statement &s )
01688 {
01689     if (_alist != 0) {
01690         for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
01691             switch (iter.current().type()) {
01692         case AS_OVERLAP:
01693         generate_csrd_overlap_directive( s, iter.current() );
01694         break;
01695         case AS_OVERLAP_SORT:
01696         generate_csrd_overlap_sort_directive( s, iter.current() );
01697         break;
01698         case AS_PRIVATE_DESCR:
01699         generate_csrd_private_descr_directive( s, iter.current() );
01700         break;
01701         case AS_TEST_MONOTONE:
01702         generate_csrd_test_monotone_directive( s, iter.current() );
01703         break;
01704         case AS_REDUCT_DESCR:
01705         generate_csrd_reduct_descr_directive( s, iter.current() );
01706         break;
01707         case AS_DEP_OVERLAP:
01708         generate_csrd_dep_overlap_directive( s, iter.current() );
01709         break;
01710         case AS_DEP_RO_RW:
01711         generate_csrd_dep_ROvsRW_directive( s, iter.current() );
01712         break;
01713         case AS_DEP_RW_WF:
01714         generate_csrd_dep_RWvsWF_directive( s, iter.current() );
01715         break;
01716         case AS_DEP_WF_RO:
01717         generate_csrd_dep_WFvsRO_directive( s, iter.current() );
01718         break;
01719             case AS_PRIVATE:
01720                 generate_csrd_private_directive( s, iter.current() );
01721                 break;
01722             case AS_RELATION:
01723                 generate_csrd_assert_directive( s, iter.current() );
01724                 break;
01725         case AS_INSTRUMENT:
01726         generate_csrd_instrument_directive( s, iter.current() );
01727         break;
01728             case AS_SAFE_CONDITION:
01729                 generate_csrd_safe_condition_directive( s, iter.current() );
01730                 break;
01731             case AS_SERIAL:
01732                 generate_csrd_serial_directive( s, iter.current() );
01733                 break;
01734             case AS_CRITICAL:
01735                 generate_csrd_critical_directive( s, iter.current() );
01736                 break;
01737             case AS_REDUCTION:
01738                 generate_csrd_reduction_directive( s, iter.current() );
01739                 break;
01740             case AS_LASTVALUE:
01741                 generate_csrd_lastvalue_directive( s, iter.current() );
01742                 break;
01743             case AS_DYNLASTVALUE:
01744                 generate_csrd_dynlastvalue_directive( s, iter.current() );
01745                 break;
01746             case AS_FIRSTVALUE:
01747                 generate_csrd_firstvalue_directive( s, iter.current() );
01748                 break;
01749         case AS_FORWARD:
01750         generate_csrd_forward_directive( s, iter.current() );
01751         break;
01752         case AS_RANGEWRITTEN:
01753         generate_csrd_rangewritten_directive( s, iter.current() );
01754         break;
01755             case AS_PROLOGUE:
01756                 generate_csrd_prologue_directive( s, iter.current() );
01757                 break;
01758             case AS_EPILOGUE:
01759                 generate_csrd_epilogue_directive( s, iter.current() );
01760                 break;
01761             case AS_PARALLEL:
01762                 generate_csrd_parallel_directive( s, iter.current() );
01763                 break;
01764             case AS_COMMENT:
01765                 generate_comment_directive( s, iter.current() );
01766                 break;
01767             case AS_LOOPLABEL:
01768                 generate_csrd_looplabel_directive( s, iter.current() );
01769                 break;
01770             case AS_INDUCTION:
01771                 generate_csrd_induction_directive( s, iter.current() );
01772                 break;
01773              case AS_PARCONDITION:
01774                 generate_csrd_parcondition_directive( s, iter.current() );
01775                 break;
01776         case AS_NOPUTGET:
01777         generate_csrd_noputget_directive( s, iter.current() );
01778         break;
01779         case AS_MAYMOD:
01780         generate_csrd_maymod_directive( s, iter.current() );
01781         break;
01782         case AS_NOMOD:
01783         generate_csrd_nomod_directive( s, iter.current() );
01784         break;
01785             case AS_SHARED:
01786                 generate_csrd_shared_directive( s, iter.current() );
01787                 break;
01788         case AS_PRIVATEREFS:
01789         generate_csrd_privaterefs_directive( s, iter.current() );
01790         break;
01791         case AS_READONLYREFS:
01792         generate_csrd_readonlyrefs_directive( s, iter.current() );
01793         break;
01794         case AS_SHAREDREFS:
01795         generate_csrd_sharedrefs_directive( s, iter.current() );
01796         break;
01797         case AS_RTSHADOW:
01798         generate_csrd_rtshadow_directive( s, iter.current() );
01799         break;
01800         case AS_DEP_IO:
01801         generate_csrd_dep_io_directive( s, iter.current() );
01802         break;
01803         case AS_INLINE:
01804         generate_csrd_inline_directive( s, iter.current() );
01805         break;
01806         case AS_RECURSIVEINLINE:
01807         generate_csrd_recursive_inline_directive( s, iter.current() );
01808         break;
01809         case AS_NOINLINE:
01810         generate_csrd_noinline_directive( s, iter.current() );
01811         break;
01812         case AS_RUNTIMETEST:
01813         generate_csrd_runtimetest_directive( s, iter.current() );
01814         break;
01815         case AS_NODEPENDENCE:
01816         generate_csrd_nodependence_directive( s, iter.current() );
01817         break;
01818         case AS_SIDE_EFFECT_FREE:
01819         generate_csrd_sideeffectfree_directive( s, iter.current() );
01820         break;
01821         case AS_SCHEDULE:
01822         generate_csrd_schedule_directive( s, iter.current() );
01823         break;
01824         case AS_PREAMBLE:
01825         generate_csrd_preamble_directive( s, iter.current() );
01826         break;
01827         case AS_POSTAMBLE:
01828         generate_csrd_postamble_directive( s, iter.current() );
01829         break;
01830         case AS_RECURRENCE:
01831                 generate_recurrence_directive( s, iter.current() );
01832           break;
01833             default:
01834                 p_abort( "unknown CSRD assertion type" );
01835                 break;
01836             }
01837         }
01838     }
01839 }
01840 
01841 void
01842 Directive::generate_comment_directive( Statement &s )
01843 {
01844     if (_alist != 0) {
01845         for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
01846             switch (iter.current().type()) {
01847             case AS_COMMENT:
01848                 generate_comment_directive( s, iter.current() );
01849                 break;
01850             default:
01851                 break;
01852             }
01853         }
01854     }
01855 }
01856 
01857 void
01858 Directive::generate_hpf_directive( Statement & NOTUSED(s) )
01859 {
01860     /// ...  nothing to do
01861 }
01862 
01863 void
01864 Directive::generate_cray_directive( Statement &s )
01865 {
01866     if (_alist != 0) {
01867         for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
01868             switch (iter.current().type()) {
01869         case AS_OVERLAP:
01870         generate_csrd_overlap_directive( s, iter.current() );
01871         break;
01872         case AS_OVERLAP_SORT:
01873         generate_csrd_overlap_sort_directive( s, iter.current() );
01874         break;
01875         case AS_PRIVATE_DESCR:
01876         generate_csrd_private_descr_directive( s, iter.current() );
01877         break;
01878         case AS_TEST_MONOTONE:
01879         generate_csrd_test_monotone_directive( s, iter.current() );
01880         break;
01881         case AS_REDUCT_DESCR:
01882         generate_csrd_reduct_descr_directive( s, iter.current() );
01883         break;
01884         case AS_DEP_OVERLAP:
01885         generate_csrd_dep_overlap_directive( s, iter.current() );
01886         break;
01887         case AS_DEP_RO_RW:
01888         generate_csrd_dep_ROvsRW_directive( s, iter.current() );
01889         break;
01890         case AS_DEP_RW_WF:
01891         generate_csrd_dep_RWvsWF_directive( s, iter.current() );
01892         break;
01893         case AS_DEP_WF_RO:
01894         generate_csrd_dep_WFvsRO_directive( s, iter.current() );
01895         break;
01896             case AS_PRIVATE:
01897                 generate_csrd_private_directive( s, iter.current() );
01898                 break;
01899             case AS_SHARED:
01900                 generate_csrd_shared_directive( s, iter.current() );
01901                 break;
01902             case AS_RELATION:
01903                 generate_csrd_assert_directive( s, iter.current() );
01904                 break;
01905             case AS_SAFE_CONDITION:
01906                 generate_csrd_safe_condition_directive( s, iter.current() );
01907                 break;
01908             case AS_CRITICAL:
01909                 generate_csrd_critical_directive( s, iter.current() );
01910                 break;
01911             case AS_REDUCTION:
01912                 generate_csrd_reduction_directive( s, iter.current() );
01913                 break;
01914             case AS_LASTVALUE:
01915                 generate_csrd_lastvalue_directive( s, iter.current() );
01916                 break;
01917             case AS_DYNLASTVALUE:
01918                 generate_csrd_dynlastvalue_directive( s, iter.current() );
01919                 break;
01920         case AS_FIRSTVALUE:
01921         generate_csrd_firstvalue_directive( s, iter.current() );
01922         break;
01923         case AS_FORWARD:
01924         generate_csrd_forward_directive( s, iter.current() );
01925         break;
01926         case AS_RANGEWRITTEN:
01927         generate_csrd_rangewritten_directive( s, iter.current() );
01928         break;
01929             case AS_PROLOGUE:
01930                 generate_csrd_prologue_directive( s, iter.current() );
01931                 break;
01932             case AS_EPILOGUE:
01933                 generate_csrd_epilogue_directive( s, iter.current() );
01934                 break;
01935             case AS_PARALLEL:
01936                 generate_csrd_parallel_directive( s, iter.current() );
01937                 break;
01938             case AS_COMMENT:
01939                 generate_comment_directive( s, iter.current() );
01940                 break;
01941             case AS_LOOPLABEL:
01942                 generate_csrd_looplabel_directive( s, iter.current() );
01943                 break;
01944         case AS_DEP_IO:
01945         generate_csrd_dep_io_directive( s, iter.current() );
01946         break;
01947         case AS_RECURRENCE:
01948                 generate_recurrence_directive( s, iter.current() );
01949         break;
01950             case AS_SERIAL:
01951         case AS_PRIVATEREFS:
01952         case AS_READONLYREFS:
01953         case AS_SHAREDREFS:
01954         case AS_INSTRUMENT:
01955         case AS_INLINE:
01956         case AS_RECURSIVEINLINE:
01957         case AS_NOINLINE:
01958         case AS_RUNTIMETEST:
01959         case AS_NODEPENDENCE:
01960         case AS_SIDE_EFFECT_FREE:
01961         case AS_SCHEDULE:
01962         case AS_PREAMBLE:
01963         case AS_POSTAMBLE:
01964         case AS_MAYMOD:
01965         case AS_NOMOD:
01966         break;
01967             default:
01968                 p_abort( "unknown CRAY/C90 assertion type" );
01969                 break;
01970             }
01971         }
01972     }
01973 }
01974 
01975 
01976 void
01977 Directive::generate_ksr_directive( Statement & NOTUSED(s) )
01978 {
01979     /// ...  nothing to do
01980 }
01981 
01982 
01983 void
01984 Directive::generate( Statement &s )
01985 {
01986     switch (_dtype) {
01987     case DT_CSRD:
01988     case DT_CEDAR_FORTRAN:
01989     case DT_CF_F77:
01990     case DT_KAP_SGI:
01991         generate_csrd_directive( s );
01992         break;
01993 
01994     case DT_CONVEX:
01995         generate_convex_directive( s );
01996         break;
01997 
01998     case DT_SGI:
01999     case DT_SGI_POWER:
02000         generate_sgi_directive( s );
02001         break;
02002 
02003     /// ... Begin OpenMP Modification
02004 
02005     case DT_OMP:
02006         generate_omp_directive( s );
02007     break;
02008 
02009     /// ... End OpenMP Modification
02010 
02011     case DT_HPF:
02012         generate_hpf_directive( s );
02013         break;
02014 
02015     case DT_KSR:
02016         generate_ksr_directive( s );
02017         break;
02018 
02019     case DT_CRAY:
02020         generate_cray_directive( s );
02021         break;
02022 
02023     case DT_COMMENT:
02024         generate_comment_directive( s );
02025         break;
02026 
02027     case DT_CRAY_T3D:
02028     case DT_TREADMARKS:
02029     case DT_FAST_MESSAGES:
02030         generate_cray_t3d_directive( s );
02031         break;
02032 
02033     case DT_CONVEX_SPP:
02034         generate_convex_spp_directive( s );
02035         break;
02036 
02037     case DT_ZHU:
02038       generate_csrd_directive(s);
02039       break;
02040       
02041 
02042     default:
02043         p_abort( "Directive::generate: error unknown type" );
02044         break;
02045     }
02046 }
02047 
02048 /// Begin OpenMP Modification
02049 
02050 //------------------------------------------------------------------------
02051 
02052 void
02053 Directive::generate_omp_parallel_directive( Statement &s, Assertion &a )
02054 {
02055   RefSet<Symbol> privates;
02056   RefSet<Symbol> shareds;
02057   RefSet<Symbol> lastval;
02058   RefSet<Symbol> scalar_reducts;
02059   RefSet<Expression> reducts;
02060   Expression *condition_expr = NULL;
02061   
02062   p_assert( a.type() == AS_PREAMBLE, "not a parallel assertion" );
02063 
02064 /// First make sure there is an enclosed parallel loop
02065 /// if not, don't generate a parallel region
02066 
02067   if(!(parallel_loop_inside(&s))) {
02068     remove_preamble(&s);
02069     remove_postamble(&s);
02070     return;
02071   }
02072 
02073   for (Iterator <Assertion> a_iter = s.assertions();
02074        a_iter.valid(); ++a_iter) {
02075     switch ( a_iter.current().type() ) {
02076     case AS_PRIVATE:
02077       if (a_iter.current().arg_list_valid())
02078     for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02079          iter.valid();
02080          ++iter)
02081       privates.ins(*(iter.current().base_variable_ref()));
02082       break;
02083 
02084     case AS_SHARED:
02085       if (a_iter.current().arg_list_valid()) 
02086     for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02087          iter.valid();
02088          ++iter) 
02089       shareds.ins(*(iter.current().base_variable_ref()));
02090       break;
02091 
02092     case AS_LASTVALUE:
02093       if (a_iter.current().arg_list_valid()) 
02094     for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02095          iter.valid();
02096          ++iter)
02097       lastval.ins(*(iter.current().base_variable_ref()));
02098       break;
02099 
02100     case AS_PARCONDITION:
02101       if (a_iter.current().arg_list_valid()) {
02102     Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02103     if (iter.valid()) 
02104       condition_expr = &(iter.current());
02105       }
02106       break;
02107 
02108     default:
02109       break;
02110     }
02111   }
02112 
02113   privates -= shareds;
02114   privates -= lastval;
02115 
02116 /// Now generate the directives:
02117 
02118   StringElem *se = new StringElem("!$OMP PARALLEL");
02119   text_list().ins_first( se );
02120   
02121   if (condition_expr != NULL) {
02122     strstream  o;
02123     o << "!$OMP+IF(" ;
02124     o << *simplify(condition_expr->clone());
02125         /// ... o << *condition_expr;
02126     o << ")";
02127     o << '\0';
02128 
02129         /// ...  Start of Modification by baeh
02130         char *sentinel = "!$OMP+";
02131         char *data = o.str();
02132         char *save = data;
02133         int sentinel_len = strlen(sentinel);
02134         int len = strlen(data);
02135         const int line_width = 72;
02136 
02137         while (len > line_width) {
02138             int i;
02139 
02140             for (i = line_width-1; i > 0; --i) ; /// ...  nothing to do
02141 
02142       if (i == 0) {
02143                 for (i = line_width-1; i > 0; --i) {
02144                     char c = data[i];
02145                     if (c == '+' || c == '-' || c == '(' || c == ')' || c == ':')
02146                         break;
02147                 }
02148             }
02149             String str(data, i);
02150             se = new StringElem(str);
02151             text_list().ins_first(se);
02152             data += (i - sentinel_len);
02153             int j;
02154             for (j = 0; j < sentinel_len; j++) {
02155                 data[j] = sentinel[j];
02156             }
02157             len = strlen(data);
02158         }
02159         se = new StringElem(data);
02160         text_list().ins_first(se);
02161         delete save;
02162     /// ... o << endl;
02163     /// ... p_assert(strlen(o.str()) < 72, "If directive too long");
02164     /// ... text_list().ins_first(new StringElem(o.str()));
02165   }
02166 
02167   se = new StringElem("!$OMP+DEFAULT(SHARED)");
02168   text_list().ins_first( se );
02169 
02170   if (privates.entries() > 0) {
02171     strstream  o;
02172     o << "!$OMP+PRIVATE(";
02173     Iterator<Symbol> iter=privates;
02174     if (iter.valid()) {
02175       o << iter.current().name_ref();
02176       ++iter;
02177     }
02178     for (; iter.valid(); ++iter) {
02179       o << ",";
02180       o << iter.current().name_ref();
02181     }
02182     o << ")";
02183     o << '\0';
02184     break_line("!$OMP+","PRIVATE(",o);
02185   }
02186 
02187   for (Mutator<StringElem> se_iter = text_list();
02188        se_iter.valid(); 
02189        ++se_iter) {
02190     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
02191     d.ins_first( se_iter.grab() );
02192   }
02193 }
02194 
02195 void
02196 Directive::generate_omp_do_directive( Statement &s, Assertion &a ) {
02197   p_assert( a.type() == AS_PARALLEL, "not a PDO assertion" );
02198 
02199   Boolean nowait = False;
02200   RefSet<Symbol> scalar_reducts;
02201   RefSet<Expression> reducts;
02202   RefSet<Symbol> firstval;
02203   RefSet<Symbol> lastval;
02204   RefSet<Symbol> shareds;
02205   String schedule;
02206 
02207   schedule = "STATIC";
02208 
02209   for (Iterator <Assertion> a_iter = s.assertions();
02210        a_iter.valid(); ++a_iter) {
02211     switch ( a_iter.current().type() ) {
02212     case AS_REDUCTION:
02213       if (switch_value("scalar_gen") == 0) {
02214     if (a_iter.current().arg_list_valid()) {
02215       for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02216            iter.valid(); 
02217            ++iter) {
02218         reducts.ins(iter.current());
02219       }
02220     }
02221       }
02222       break;
02223         
02224     case AS_SCHEDULE:
02225       if (a_iter.current().string_arg_list_valid()) {
02226     Iterator<StringElem> iter = a_iter.current().string_arg_list_guarded();
02227     if (iter.valid()) 
02228       schedule = iter.current();
02229       }
02230       break;
02231 
02232     case AS_NOWAIT:
02233       nowait = True;
02234       break;
02235 
02236     default:
02237       break;
02238     }
02239   }
02240 
02241   Statement *preamble = find_preamble(&s);
02242 
02243   p_assert(preamble != NULL, "No Preamble Found, Uh Oh!");
02244 
02245   for ( Iterator <Assertion> a_iter = preamble->assertions();
02246         a_iter.valid(); 
02247     ++a_iter) {
02248     switch(a_iter.current().type()) {
02249     case AS_SHARED:
02250       if(a_iter.current().arg_list_valid())
02251     for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02252          iter.valid();
02253          ++iter) 
02254       shareds.ins(*(iter.current().base_variable_ref()));
02255       break;
02256 
02257     case AS_LASTVALUE:
02258       if (a_iter.current().arg_list_valid()) 
02259     for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02260          iter.valid();
02261          ++iter)
02262       lastval.ins(*(iter.current().base_variable_ref()));
02263       break;
02264     default:
02265       break;
02266     }
02267   }
02268 
02269   lastval -= shareds;
02270 
02271 /// Now generate the directives:
02272 
02273   if (reducts.entries() > 0 ) {
02274     strstream  o;
02275     o << "!$OMP+REDUCTION(+:";
02276     Iterator<Expression> iter=reducts;
02277     if (iter.valid()) {
02278       o << iter.current();
02279       ++iter;
02280     }
02281     for (;
02282      iter.valid();
02283      ++iter) {
02284       o << ",";
02285       o << iter.current();
02286     }
02287     o << ")";
02288     o << '\0';
02289 
02290     break_line("!$OMP+","REDUCTION(+:",o);
02291   }
02292    
02293   if (schedule == "INTERLEAVED") {
02294     StringElem *se = new StringElem("!$OMP+SCHEDULE(STATIC,1)");
02295     text_list().ins_first( se );
02296   }
02297   
02298   if (lastval.entries() > 0) {
02299     strstream   o;
02300     o << "!$OMP+LASTPRIVATE(";
02301     Iterator<Symbol> iter=lastval;
02302     
02303     if (iter.valid()) {
02304       o << iter.current().name_ref();
02305       ++iter;
02306     }
02307     
02308     for (; iter.valid(); ++iter) {
02309       o << ",";
02310       o << iter.current().name_ref();
02311     }
02312     
02313     o << ")";
02314     o << '\0';
02315     break_line("!$OMP+","FIRSTPRIVATE(",o);
02316   }
02317 
02318   StringElem  *se = new StringElem("!$OMP DO");
02319   text_list().ins_first( se );
02320   
02321   for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
02322     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
02323     d.ins_last( s_iter.grab() );
02324   }
02325   
02326   if(nowait)
02327     text_list().ins_last( new StringElem( "!$OMP END DO NOWAIT" ));
02328   else
02329       text_list().ins_last( new StringElem( "!$OMP END DO" ));
02330 
02331 
02332   for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
02333     List<StringElem> &d = 
02334       CASTAWAY(List<StringElem> &) s.follow_ref()->post_directives();
02335     d.ins_last( s_iter.grab() );
02336   }
02337 }
02338 
02339 void
02340 Directive::generate_omp_end_parallel_directive( Statement &s, Assertion &a )
02341 {
02342   p_assert( a.type() == AS_POSTAMBLE, "not a PDO assertion" );
02343 
02344   text_list().ins_last( new StringElem( "!$OMP END PARALLEL" ));
02345 
02346   for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
02347     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
02348     d.ins_last( s_iter.grab() );
02349   }
02350 }
02351 
02352 void
02353 Directive::generate_omp_critical_directive( Statement &s, Assertion &a )
02354 {
02355   Boolean nowait = False;
02356   Statement *end;
02357 
02358   p_assert( a.type() == AS_CRITICAL, "not a critical assertion" );
02359 
02360   for (Iterator <Assertion> a_iter = s.assertions();
02361        a_iter.valid(); ++a_iter) {
02362     if(a_iter.current().type() == AS_NOWAIT)
02363       nowait = True;
02364   }
02365 
02366   text_list().ins_last( new StringElem("!$OMP CRITICAL"));
02367 
02368   for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
02369     List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
02370     d.ins_last( s_iter.grab() );
02371   }
02372 
02373   if(s.stmt_class() == DO_STMT) 
02374     end = s.follow_ref();
02375   else
02376     end = &s;
02377 
02378   if(nowait)
02379     text_list().ins_last( new StringElem("!$OMP END CRITICAL NOWAIT"));
02380   else
02381     text_list().ins_last( new StringElem("!$OMP END CRITICAL"));
02382 
02383   for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
02384     List<StringElem> &d = CASTAWAY(List<StringElem> &) end->post_directives();
02385     d.ins_last( s_iter.grab() );
02386   }
02387 }
02388 
02389 void
02390 Directive::generate_omp_directive( Statement &s ) {
02391 ///  cout<<"generate omp directive for statement"<<endl;
02392 ///  s.print(cout); cout<<endl;
02393   int debug = switch_value("omp_debug");
02394   if (_alist != 0) {
02395     for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
02396       switch (iter.current().type()) {
02397 
02398       case AS_PREAMBLE:
02399     generate_omp_parallel_directive( s, iter.current() );
02400     break;
02401       case AS_POSTAMBLE:
02402     generate_omp_end_parallel_directive( s, iter.current() );
02403     break;
02404       case AS_CRITICAL:
02405     generate_omp_critical_directive( s, iter.current() );
02406     break;
02407       case AS_PARALLEL:
02408     generate_omp_do_directive( s, iter.current() );
02409     break;
02410 
02411       /// ...  The next four directives are covered by AS_PARALLEL
02412       case AS_PRIVATE:
02413     if (debug) generate_csrd_private_directive( s, iter.current() );
02414     break;
02415       case AS_REDUCTION:
02416     if (debug) generate_csrd_reduction_directive( s, iter.current() );
02417     break;
02418       case AS_LASTVALUE:
02419     if (debug) generate_csrd_lastvalue_directive( s, iter.current() );
02420     break;
02421       case AS_SCHEDULE:
02422     if (debug) generate_csrd_schedule_directive( s, iter.current() );
02423 
02424       case AS_PARCONDITION:
02425       case AS_NOWAIT:  /// ...  this is covered the applicable directives
02426       case AS_PARTIAL_REDUCTION: /// ... Guobin
02427       case AS_PARTIAL_FIRSTVALUE: /// ... Guobin
02428     break;
02429       case AS_SHARED:
02430     if (debug) generate_csrd_shared_directive( s, iter.current() );
02431     break;
02432       case AS_INDUCTION:
02433     if (debug) generate_csrd_induction_directive( s, iter.current() );
02434     break;
02435       case AS_MAYMOD:
02436     if (debug) generate_csrd_maymod_directive( s, iter.current() );
02437     break;
02438       case AS_NOMOD:
02439     if (debug) generate_csrd_nomod_directive( s, iter.current() );
02440     break;
02441       case AS_DYNLASTVALUE:
02442     if (debug) generate_csrd_dynlastvalue_directive( s, iter.current() );
02443     break;
02444       case AS_FIRSTVALUE:
02445     if (debug) generate_csrd_firstvalue_directive( s, iter.current() );
02446     break;
02447       case AS_RANGEWRITTEN:
02448     if (debug) generate_csrd_rangewritten_directive( s, iter.current() );
02449     break;
02450       case AS_RELATION:
02451     if (debug) generate_csrd_assert_directive( s, iter.current() );
02452     break;
02453       case AS_SAFE_CONDITION:
02454     if (debug) generate_csrd_safe_condition_directive( s, iter.current() );
02455     break;
02456       case AS_INSTRUMENT:
02457     break;
02458       case AS_PROLOGUE:
02459     if (debug) generate_csrd_prologue_directive( s, iter.current() );
02460     break;
02461       case AS_EPILOGUE:
02462     if (debug) generate_csrd_epilogue_directive( s, iter.current() );
02463     break;
02464       case AS_SERIAL:
02465     if (debug) generate_csrd_serial_directive( s, iter.current() );
02466     break;
02467       case AS_COMMENT:
02468     if (debug) generate_comment_directive( s, iter.current() );
02469     break;
02470       case AS_LOOPLABEL:
02471     generate_csrd_looplabel_directive( s, iter.current() );
02472     break;
02473       case AS_PRIVATEREFS:
02474     if (debug) generate_csrd_privaterefs_directive( s, iter.current() );
02475     break;
02476       case AS_READONLYREFS:
02477     if (debug) generate_csrd_readonlyrefs_directive( s, iter.current() );
02478     break;
02479       case AS_SHAREDREFS:
02480     if (debug) generate_csrd_sharedrefs_directive( s, iter.current() );
02481     break;
02482       case AS_INLINE:
02483     if (debug) generate_csrd_inline_directive( s, iter.current() );
02484     break;
02485       case AS_NOINLINE:
02486     if (debug) generate_csrd_noinline_directive( s, iter.current() );
02487     break;
02488       case AS_RUNTIMETEST:
02489     if (debug) generate_csrd_runtimetest_directive( s, iter.current() );
02490     break;
02491       case AS_NODEPENDENCE:
02492     if (debug) generate_csrd_nodependence_directive( s, iter.current() );
02493     break;
02494       default:
02495     p_abort( "unknown OpenMP assertion type" );
02496     break;
02497       }
02498     }
02499   }
02500 }
02501 
02502 void
02503 Directive::break_line(char * sentinel, char * subdir, strstream &o) {
02504   char *data = o.str();
02505   char *save = data;
02506 
02507   int sentinel_len = strlen(sentinel);
02508   int len = strlen( data );
02509   int sublen = strlen(subdir);
02510 
02511   const int line_width = 72;
02512 
02513   while ( len > line_width ) {
02514     int i;
02515     for (i = line_width-1; i > 0; --i) {
02516       if (data[i] == ',') {
02517     if(sublen > 0)
02518       data[i] = ')';
02519     break;
02520       }
02521     }
02522     
02523     p_assert(i>0, "No Place to Break Directive");
02524 
02525     String str( data, i+1 );
02526     StringElem *se = new StringElem( str );
02527     text_list().ins_first( se );
02528     
02529     data += ( i - sentinel_len - sublen);
02530       
02531     int j;
02532 
02533     for(j = 0; j < sentinel_len; j++) {
02534       data[j] = sentinel[j];
02535     }
02536 
02537     for(j=0; j < sublen; j++)
02538       data[sentinel_len+j] = subdir[j];
02539     data[sentinel_len+sublen] = ' ';
02540 
02541     len = strlen( data );
02542   }
02543 
02544   StringElem  *se = new StringElem( data );
02545   text_list().ins_first( se );
02546   delete save;
02547 }
02548 
02549 /// End OpenMP Modification
02550 
02551 
02552 //------------------------------------------------------------------------
02553 
02554 void
02555 Directive::generate_sgi_prologue_directive( Statement & NOTUSED(s), 
02556                                             Assertion & NOTUSED(a) )
02557 {
02558     /// ...  No corresponding SGI directive!
02559     /// ...  This is handled by the AS_PARALLEL assertion.
02560 }
02561 
02562 void
02563 Directive::generate_sgi_epilogue_directive( Statement & NOTUSED(s), 
02564                                             Assertion & NOTUSED(a) )
02565 {
02566     /// ...  No corresponding SGI directive!
02567     /// ...  This is handled by the AS_PARALLEL assertion.
02568 }
02569 
02570 void
02571 Directive::generate_sgi_parallel_directive( Statement &s, Assertion &a )
02572 {
02573     p_assert( a.type() == AS_PARALLEL, "not a parallel assertion" );
02574 
02575     AssertParallel &ap = (AssertParallel &) a;
02576 
02577     Iterator<Assertion> a_iter = ap.assertion_list(); 
02578 
02579     for ( ; a_iter.valid(); ++a_iter) {
02580         if (a_iter.current().type() == AS_PROLOGUE) {
02581             /// ...  normally we would return, but for SGI we won't.
02582         }
02583     }
02584 
02585     RefSet<Symbol> privates;
02586     RefSet<Symbol> lastvals;
02587     RefSet<Symbol> shareds;
02588     RefSet<Symbol> scalar_reducts;
02589     RefSet<Expression> reducts;
02590     String schedule;
02591     Expression *condition_expr = NULL;
02592 
02593     schedule = "SIMPLE";
02594     
02595     for ( a_iter = s.assertions(); a_iter.valid(); ++a_iter) {
02596         switch ( a_iter.current().type() ) {
02597         case AS_LASTVALUE:
02598             {
02599         if (a_iter.current().arg_list_valid()) {
02600             for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02601              iter.valid();
02602              ++iter)
02603             {
02604                 lastvals.ins(*(iter.current().base_variable_ref()));
02605             }
02606         }
02607         }
02608             break;
02609 
02610         case AS_PRIVATE:
02611             {
02612         if (a_iter.current().arg_list_valid()) {
02613             for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02614              iter.valid();
02615              ++iter)
02616             {
02617                 privates.ins(*(iter.current().base_variable_ref()));
02618             }
02619         }
02620             }
02621             break;
02622 
02623         case AS_SHARED:
02624             {
02625         if (a_iter.current().arg_list_valid()) {
02626             for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02627              iter.valid();
02628              ++iter)
02629             {
02630                 shareds.ins(*(iter.current().base_variable_ref()));
02631             }
02632         }
02633             }
02634             break;
02635 
02636     case AS_SCHEDULE:
02637         {
02638         if (a_iter.current().string_arg_list_valid()) {
02639             Iterator<StringElem> iter = a_iter.current().string_arg_list_guarded();
02640             if (iter.valid()) {
02641             schedule = iter.current();
02642             }
02643         }
02644         }
02645         break;
02646         
02647     case AS_PARCONDITION:
02648         {
02649         if (a_iter.current().arg_list_valid()) {
02650             Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02651             if (iter.valid()) {
02652              condition_expr = &(iter.current());
02653             }
02654         }
02655         }
02656         break;
02657         
02658         case AS_REDUCTION:
02659             {
02660         if (a_iter.current().arg_list_valid()) {
02661             for (Iterator<Expression> iter = a_iter.current().arg_list_guarded();
02662              iter.valid();
02663              ++iter)
02664             {
02665                 reducts.ins(iter.current());
02666                 Symbol &sym = *(iter.current().base_variable_ref());
02667                 if (sym.is_scalar()) {
02668                 scalar_reducts.ins(sym);
02669                 }
02670             }
02671         }
02672             }
02673             break;
02674     default:
02675         break;
02676         }
02677     }
02678 
02679     /// ...  Since the AS_PRIVATE assertion is defined to contain ALL private
02680     /// ...  variables (even those needing last value assignment), and the
02681     /// ...  SGI directives define the private list and the last value list
02682     /// ...  to have no common variables, we must remove the last-value
02683     /// ...  list from the private list.
02684 
02685     privates -= lastvals;
02686 
02687     /// ...  Remove the scalar reductions from the SHARED list
02688 
02689     shareds -= scalar_reducts;
02690     
02691     /// ...  SGI requires that the parallel DO index be in the private list
02692     /// ...  (and NOT on the SHARE list)
02693 
02694     Symbol &doindex = *(s.index().base_variable_ref());
02695     privates.ins(doindex);
02696     shareds.del(doindex);
02697     
02698     strstream   o;
02699     Boolean need_comma = False;
02700 
02701     o << "C$DOACROSS ";
02702 
02703     if (condition_expr != NULL) {
02704         o << "IF(" ;
02705         o << *condition_expr;
02706         o << ")";
02707         need_comma = True;
02708     }
02709 
02710     if (privates.entries() > 0) {
02711     if (need_comma) {
02712         o << ",";
02713     }
02714     o << "LOCAL(";
02715     Iterator<Symbol> iter=privates;
02716     if (iter.valid()) {
02717         o << iter.current().name_ref();
02718         ++iter;
02719     }
02720     for (;
02721         iter.valid();
02722          ++iter)
02723         {
02724         o << ",";
02725         o << iter.current().name_ref();
02726         }
02727     o << ")";
02728     need_comma = True;
02729     }
02730 
02731     if (lastvals.entries() > 0) {
02732     if (need_comma) {
02733         o << ",";
02734     }
02735 
02736     o << "LASTLOCAL(";
02737     Iterator<Symbol> iter=lastvals;
02738     if (iter.valid()) {
02739         o << iter.current().name_ref();
02740         ++iter;
02741     }
02742     for (;
02743         iter.valid();
02744          ++iter)
02745         {
02746         o << ",";
02747         o << iter.current().name_ref();
02748         }
02749     o << ")";
02750     need_comma = True;
02751     }
02752 
02753     if (shareds.entries() > 0) {
02754     if (need_comma) {
02755         o << ",";
02756     }
02757 
02758     o << "SHARE(";
02759     Iterator<Symbol> iter=shareds;
02760     if (iter.valid()) {
02761         o << iter.current().name_ref();
02762         ++iter;
02763     }
02764     for (;
02765         iter.valid();
02766          ++iter)
02767         {
02768         o << ",";
02769         o << iter.current().name_ref();
02770         }
02771     o << ")";
02772     need_comma = True;
02773     }
02774 
02775     if (reducts.entries() > 0) {
02776     if (need_comma) {
02777         o << ",";
02778     }
02779 
02780     o << "REDUCTION(";
02781     Iterator<Expression> iter=reducts;
02782     if (iter.valid()) {
02783             o << directive_get_sym_name( iter.current() );
02784         /// ...  o << iter.current();
02785         ++iter;
02786     }
02787     for (;
02788         iter.valid();
02789          ++iter)
02790         {
02791         o << ",";
02792                 o << directive_get_sym_name( iter.current() );
02793         /// ...  o << iter.current();
02794         }
02795     o << ")";
02796     }
02797     
02798     if (schedule == "INTERLEAVED")
02799     o << ",MP_SCHEDTYPE=INTERLEAVED,CHUNK=2";
02800     
02801     o << '\0';
02802 
02803     char *data = o.str();
02804     char *save = data;
02805 
02806     int len = strlen( data );
02807 
02808     const int line_width = 72;
02809 
02810     while ( len > line_width ) {
02811     int i;
02812         for (i = line_width-1; i > 0; --i) {
02813             if (data[i] == ',')
02814                 break;
02815         }
02816 
02817         if (i < 4) {
02818             for (i = line_width-1; i > 0; --i) {
02819                 char c = data[i];
02820                 if (c == '+' || c == '-' || c == '(' || c == ')' || c == ':')
02821                     break;
02822             }
02823         }
02824 
02825         if (i < 4)
02826             break;
02827 
02828         String str( data, i+1 );
02829         StringElem *se = new StringElem( str );
02830 
02831         text_list().ins_first( se );
02832 
02833         data += ( i - 3 );
02834 
02835         data[0] = 'C';
02836         data[1] = '$';
02837         data[2] = '&';
02838         data[3] = ' ';
02839 
02840         len = strlen( data );
02841     }
02842 
02843     StringElem  *se = new StringElem( data );
02844     text_list().ins_first( se );
02845 
02846     delete save;
02847 
02848     for (Mutator<StringElem> se_iter = text_list(); 
02849                               se_iter.valid(); ++se_iter) {
02850         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.pre_directives();
02851         d.ins_first( se_iter.grab() );
02852     }
02853 }
02854 
02855 void
02856 Directive::generate_sgi_directive( Statement &s )
02857 {
02858     if (_alist != 0) {
02859         for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
02860             switch (iter.current().type()) {
02861         /// ...  The four following are handled via the AS_PARALLEL 
02862             case AS_PRIVATE:
02863             case AS_REDUCTION:
02864             case AS_LASTVALUE:
02865         case AS_SHARED:
02866         case AS_SCHEDULE:
02867         case AS_PARCONDITION:
02868             case 101:
02869                 break;
02870 
02871         case AS_OVERLAP:
02872         generate_csrd_overlap_directive( s, iter.current() );
02873         break;
02874         case AS_OVERLAP_SORT:
02875         generate_csrd_overlap_sort_directive( s, iter.current() );
02876         break;
02877         case AS_PRIVATE_DESCR:
02878         generate_csrd_private_descr_directive( s, iter.current() );
02879         break;
02880         case AS_TEST_MONOTONE:
02881         generate_csrd_test_monotone_directive( s, iter.current() );
02882         break;
02883         case AS_REDUCT_DESCR:
02884         generate_csrd_reduct_descr_directive( s, iter.current() );
02885         break;
02886         case AS_DEP_OVERLAP:
02887         generate_csrd_dep_overlap_directive( s, iter.current() );
02888         break;
02889         case AS_DEP_RO_RW:
02890         generate_csrd_dep_ROvsRW_directive( s, iter.current() );
02891         break;
02892         case AS_DEP_RW_WF:
02893         generate_csrd_dep_RWvsWF_directive( s, iter.current() );
02894         break;
02895         case AS_DEP_WF_RO:
02896         generate_csrd_dep_WFvsRO_directive( s, iter.current() );
02897         break;
02898         case AS_INSTRUMENT:
02899         generate_csrd_instrument_directive( s, iter.current() );
02900         break;
02901             case AS_INDUCTION:
02902                 generate_csrd_induction_directive( s, iter.current() );
02903                 break;
02904         case AS_MAYMOD:
02905         generate_csrd_maymod_directive( s, iter.current() );
02906         break;
02907         case AS_NOMOD:
02908         generate_csrd_nomod_directive( s, iter.current() );
02909         break;
02910             case AS_DYNLASTVALUE:
02911         generate_csrd_dynlastvalue_directive( s, iter.current() );
02912         break;
02913         case AS_FIRSTVALUE:
02914         generate_csrd_firstvalue_directive( s, iter.current() );
02915         break;
02916         case AS_FORWARD:
02917         generate_csrd_forward_directive( s, iter.current() );
02918         break;
02919         case AS_RANGEWRITTEN:
02920         generate_csrd_rangewritten_directive( s, iter.current() );
02921         break;
02922             case AS_RELATION:
02923                 generate_csrd_assert_directive( s, iter.current() );
02924                 break;
02925             case AS_SAFE_CONDITION:
02926                 generate_csrd_safe_condition_directive( s, iter.current() );
02927                 break;
02928             case AS_CRITICAL:
02929                 generate_csrd_critical_directive( s, iter.current() );
02930                 break;
02931             case AS_PROLOGUE:
02932                 generate_sgi_prologue_directive( s, iter.current() );
02933                 break;
02934             case AS_EPILOGUE:
02935                 generate_sgi_epilogue_directive( s, iter.current() );
02936                 break;
02937             case AS_PARALLEL:
02938                 generate_sgi_parallel_directive( s, iter.current() );
02939                 break;
02940             case AS_COMMENT:
02941                 generate_comment_directive( s, iter.current() );
02942                 break;
02943             case AS_LOOPLABEL:
02944                 generate_csrd_looplabel_directive( s, iter.current() );
02945                 break;
02946         case AS_PRIVATEREFS:
02947         generate_csrd_privaterefs_directive( s, iter.current() );
02948         break;
02949         case AS_READONLYREFS:
02950         generate_csrd_readonlyrefs_directive( s, iter.current() );
02951         break;
02952         case AS_SHAREDREFS:
02953         generate_csrd_sharedrefs_directive( s, iter.current() );
02954         break;
02955         case AS_RTSHADOW:
02956         generate_csrd_rtshadow_directive( s, iter.current() );
02957         break;
02958         case AS_DEP_IO:
02959         generate_csrd_dep_io_directive( s, iter.current() );
02960         break;
02961         case AS_INLINE:
02962         generate_csrd_inline_directive( s, iter.current() );
02963         break;
02964         case AS_RECURSIVEINLINE:
02965         generate_csrd_recursive_inline_directive( s, iter.current() );
02966         break;
02967         case AS_NOINLINE:
02968         generate_csrd_noinline_directive( s, iter.current() );
02969         break;
02970         case AS_RUNTIMETEST:
02971         generate_csrd_runtimetest_directive( s, iter.current() );
02972         break;
02973         case AS_NODEPENDENCE:
02974         generate_csrd_nodependence_directive( s, iter.current() );
02975         break;
02976         case AS_SIDE_EFFECT_FREE:
02977         generate_csrd_sideeffectfree_directive( s, iter.current() );
02978         break;
02979         case AS_PREAMBLE:
02980         generate_csrd_preamble_directive( s, iter.current() );
02981         break;
02982         case AS_POSTAMBLE:
02983         generate_csrd_postamble_directive( s, iter.current() );
02984         break;
02985             case AS_SERIAL:
02986         break;
02987         case AS_RECURRENCE:
02988                 generate_recurrence_directive( s, iter.current() );
02989             break;
02990             default:
02991                 p_abort( "unknown SGI assertion type" );
02992                 break;
02993             }
02994         }
02995     }
02996 }
02997 
02998 //_
02999 void
03000 Directive::generate_cray_t3d_shared_directive( Statement &s, Assertion &a )
03001 {
03002     p_assert( a.type() == AS_SHARED, "not a shared assertion" );
03003     /*p_assert( s.stmt_class() == FLOW_ENTRY_STMT,
03004       "shared assertions must not be bound to the ordinary statement" );*/
03005     AssertShared &ap = (AssertShared &) a;
03006 
03007     Iterator<Expression> iter = ap.arg_list_guarded();
03008 
03009     dir_generate_expression_list(text_list(), "CDIR$ SHARED ", ", ", "", iter);
03010 
03011     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
03012         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
03013         d.ins_last( s_iter.grab() );
03014     }
03015 }
03016 
03017 //_
03018 void
03019 Directive::generate_cray_t3d_private_directive( Statement &s, Assertion &a )
03020 {
03021     p_assert( a.type() == AS_PRIVATE, "not a private assertion" );
03022     AssertPrivate &ap = (AssertPrivate &) a;
03023 
03024     Iterator<Expression> iter = ap.arg_list_guarded();
03025 
03026     dir_generate_expression_list(text_list(), "CDIR$ PE_PRIVATE ", ", ", "", iter);
03027 
03028     for (Mutator<StringElem> s_iter = text_list(); s_iter.valid(); ++s_iter) {
03029         List<StringElem> &d = CASTAWAY(List<StringElem> &) s.post_directives();
03030         d.ins_last( s_iter.grab() );
03031     }
03032 }
03033 
03034 void
03035 Directive::generate_cray_t3d_directive( Statement &s )
03036 {
03037     if (_alist != 0) {
03038         for (Iterator<Assertion> iter = *_alist; iter.valid(); ++iter) {
03039             switch (iter.current().type()) {
03040         case AS_OVERLAP:
03041         generate_csrd_overlap_directive( s, iter.current() );
03042         break;
03043         case AS_OVERLAP_SORT:
03044         generate_csrd_overlap_sort_directive( s, iter.current() );
03045         break;
03046         case AS_PRIVATE_DESCR:
03047         generate_csrd_private_descr_directive( s, iter.current() );
03048         break;
03049         case AS_TEST_MONOTONE:
03050         generate_csrd_test_monotone_directive( s, iter.current() );
03051         break;
03052         case AS_REDUCT_DESCR:
03053         generate_csrd_reduct_descr_directive( s, iter.current() );
03054         break;
03055         case AS_DEP_OVERLAP:
03056         generate_csrd_dep_overlap_directive( s, iter.current() );
03057         break;
03058         case AS_DEP_RO_RW:
03059         generate_csrd_dep_ROvsRW_directive( s, iter.current() );
03060         break;
03061         case AS_DEP_RW_WF:
03062         generate_csrd_dep_RWvsWF_directive( s, iter.current() );
03063         break;
03064         case AS_DEP_WF_RO:
03065         generate_csrd_dep_WFvsRO_directive( s, iter.current() );
03066         break;
03067         /// ... _
03068             case AS_PRIVATE:
03069                 generate_cray_t3d_private_directive( s, iter.current() );
03070                 break;
03071         /// ... _
03072             case AS_SHARED:
03073                 generate_cray_t3d_shared_directive( s, iter.current() );
03074                 break;
03075 
03076          case AS_NOPUTGET:
03077                 generate_csrd_assert_directive( s, iter.current() );
03078                 break;
03079             case AS_RELATION:
03080                 generate_csrd_assert_directive( s, iter.current() );
03081                 break;
03082             case AS_SAFE_CONDITION:
03083                 generate_csrd_safe_condition_directive( s, iter.current() );
03084                 break;
03085             case AS_CRITICAL:
03086                 generate_csrd_critical_directive( s, iter.current() );
03087                 break;
03088             case AS_REDUCTION:
03089                 generate_csrd_reduction_directive( s, iter.current() );
03090                 break;
03091             case AS_LASTVALUE:
03092                 generate_csrd_lastvalue_directive( s, iter.current() );
03093                 break;
03094             case AS_DYNLASTVALUE:
03095                 generate_csrd_dynlastvalue_directive( s, iter.current() );
03096                 break;
03097         case AS_FIRSTVALUE:
03098         generate_csrd_firstvalue_directive( s, iter.current() );
03099         break;
03100         case AS_FORWARD:
03101         generate_csrd_forward_directive( s, iter.current() );
03102         break;
03103         case AS_RANGEWRITTEN:
03104         generate_csrd_rangewritten_directive( s, iter.current() );
03105         break;
03106             case AS_PROLOGUE:
03107                 generate_csrd_prologue_directive( s, iter.current() );
03108                 break;
03109             case AS_EPILOGUE:
03110                 generate_csrd_epilogue_directive( s, iter.current() );
03111                 break;
03112             case AS_PARALLEL:
03113                 generate_csrd_parallel_directive( s, iter.current() );
03114                 break;
03115             case AS_COMMENT:
03116                 generate_comment_directive( s, iter.current() );
03117                 break;
03118             case AS_LOOPLABEL:
03119                 generate_csrd_looplabel_directive( s, iter.current() );
03120                 break;
03121             case AS_INDUCTION:
03122                 generate_csrd_induction_directive( s, iter.current() );
03123                 break;
03124         case AS_PARCONDITION:
03125                 generate_csrd_parcondition_directive( s, iter.current() );
03126                 break;
03127         case AS_MAYMOD:
03128         generate_csrd_maymod_directive( s, iter.current() );
03129         break;
03130         case AS_NOMOD:
03131         generate_csrd_nomod_directive( s, iter.current() );
03132         break;
03133         case AS_PRIVATEREFS:
03134         generate_csrd_privaterefs_directive( s, iter.current() );
03135         break;
03136         case AS_READONLYREFS:
03137         generate_csrd_readonlyrefs_directive( s, iter.current() );
03138         break;
03139         case AS_RTSHADOW:
03140         generate_csrd_rtshadow_directive( s, iter.current() );
03141         break;
03142         case AS_DEP_IO:
03143         generate_csrd_dep_io_directive( s, iter.current() );
03144         break;
03145         case AS_INLINE:
03146         generate_csrd_inline_directive( s, iter.current() );
03147         break;
03148         case AS_RECURSIVEINLINE:
03149         generate_csrd_recursive_inline_directive( s, iter.current() );
03150         break;
03151         case AS_NOINLINE:
03152         generate_csrd_noinline_directive( s, iter.current() );
03153         break;
03154         case AS_RUNTIMETEST:
03155         generate_csrd_runtimetest_directive( s, iter.current() );
03156         break;
03157         case AS_NODEPENDENCE:
03158         generate_csrd_nodependence_directive( s, iter.current() );
03159         break;
03160         case AS_SIDE_EFFECT_FREE:
03161         generate_csrd_sideeffectfree_directive( s, iter.current() );
03162         break;
03163         case AS_SCHEDULE:
03164         generate_csrd_schedule_directive( s, iter.current() );
03165         break;
03166         case AS_PREAMBLE:
03167         generate_csrd_preamble_directive( s, iter.current() );
03168         break;
03169         case AS_POSTAMBLE:
03170         generate_csrd_postamble_directive( s, iter.current() );
03171         break;
03172         case AS_RECURRENCE:
03173                 generate_recurrence_directive( s, iter.current() );
03174             break;
03175         default:
03176                 break;
03177             }
03178         }
03179     }
03180 }
03181 
03182 //------------------------------------------------------------------------
03183 
03184 void
03185 Directive::generate_csrd_overlap_directive( Statement &s, Assertion &a )
03186 {
03187 
03188     p_assert( a.type() == AS_OVERLAP, "not an overlap assertion" );
03189 
03190     AssertOverlap &ap = (AssertOverlap &) a;
03191 
03192     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03193      iter.valid();
03194      ++iter) {
03195     
03196     AbstractAccess & aa = iter.current();
03197 
03198     p_assert(! aa.is_imprecise(), "imprecisely sorted ARD on OVERLAP assertion");
03199 
03200     int count = 0;
03201     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03202          ad_iter.valid();
03203          ++ad_iter) {
03204 
03205         AccessDimension & ad = ad_iter.current();
03206 
03207         if (ad.check_overlap()) count++;
03208     }
03209 
03210     if (count == 0) break;
03211 
03212     strstream o;
03213     o << "CSRD$ OVERLAP ";
03214 
03215     String name = aa.symbol().name_ref();
03216     o << name << " : ";
03217 
03218     o << "(" << aa.number_of_dimensions();
03219 
03220     int i = 0;
03221     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03222          ad_iter.valid();
03223          ++ad_iter,++i) {
03224 
03225         AccessDimension & ad = ad_iter.current();
03226 
03227         if (ad.check_overlap()) {
03228         o << ", " << i;
03229         }
03230     }
03231 
03232     o << ") ";
03233 
03234     if (aa.exec_predicate_exists()) {
03235         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03236     }
03237 
03238     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03239          ad_iter.valid();
03240          ++ad_iter,++i) {
03241 
03242         AccessDimension & ad = ad_iter.current();
03243 
03244         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03245     }
03246     o << '\0';
03247 
03248         char *data = o.str();
03249         StringElem  *se = new StringElem( data );
03250         delete data;
03251 
03252         text_list().ins_last( se );
03253 
03254         for (Mutator<StringElem> se_iter = text_list(); 
03255          se_iter.valid(); ++se_iter) {
03256             List<StringElem> &d 
03257                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03258             d.ins_last( se_iter.grab() );
03259         }
03260 
03261     }
03262 }
03263 
03264 //------------------------------------------------------------------------
03265 
03266 void
03267 Directive::generate_csrd_overlap_sort_directive( Statement &s, Assertion &a )
03268 {
03269 
03270     p_assert( a.type() == AS_OVERLAP_SORT, "not an overlap assertion" );
03271 
03272     AssertOverlapSort &ap = (AssertOverlapSort &) a;
03273 
03274     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03275      iter.valid();
03276      ++iter) {
03277     
03278     AbstractAccess & aa = iter.current();
03279 
03280     p_assert(aa.is_imprecise(), "precisely sorted ARD on OVERLAP_SORT assertion");
03281 
03282     int count = 0;
03283     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03284          ad_iter.valid();
03285          ++ad_iter) {
03286 
03287         AccessDimension & ad = ad_iter.current();
03288 
03289         if (ad.check_overlap()) count++;
03290     }
03291 
03292     if (count == 0) break;
03293 
03294     strstream o;
03295     o << "CSRD$ OVERLAP_SORT ";
03296 
03297     String name = aa.symbol().name_ref();
03298     o << name << " : ";
03299 
03300     o << "(" << aa.number_of_dimensions();
03301 
03302     int i = 0;
03303     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03304          ad_iter.valid();
03305          ++ad_iter,++i) {
03306 
03307         AccessDimension & ad = ad_iter.current();
03308 
03309         if (ad.check_overlap()) {
03310         o << ", " << i;
03311         }
03312     }
03313 
03314     o << ") ";
03315 
03316     if (aa.exec_predicate_exists()) {
03317         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03318     }
03319 
03320     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03321          ad_iter.valid();
03322          ++ad_iter,++i) {
03323 
03324         AccessDimension & ad = ad_iter.current();
03325 
03326         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03327     }
03328     o << '\0';
03329 
03330         char *data = o.str();
03331         StringElem  *se = new StringElem( data );
03332         delete data;
03333 
03334         text_list().ins_last( se );
03335 
03336         for (Mutator<StringElem> se_iter = text_list(); 
03337          se_iter.valid(); ++se_iter) {
03338             List<StringElem> &d 
03339                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03340             d.ins_last( se_iter.grab() );
03341         }
03342 
03343     }
03344 }
03345 
03346 void
03347 Directive::generate_csrd_private_descr_directive( Statement &s, Assertion &a )
03348 {
03349     p_assert( a.type() == AS_PRIVATE_DESCR, "not a private descriptor assertion" );
03350 
03351     AssertPrivateDescr &ap = (AssertPrivateDescr &) a;
03352 
03353     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03354      iter.valid();
03355      ++iter) {
03356     
03357     AbstractAccess & aa = iter.current();
03358 
03359         strstream   o;
03360 
03361         o << "CSRD$ PRIVATE_DESCR ";
03362     String name = aa.symbol().name_ref();
03363     o << name << " : ";
03364 
03365     if (!(aa.exec_predicate_true())) {
03366         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03367     }
03368 
03369     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03370          ad_iter.valid();
03371          ++ad_iter)
03372         {
03373         AccessDimension & ad = ad_iter.current();
03374         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03375         }
03376 
03377     o << " + " << aa.start_guarded();
03378 
03379         o << '\0';
03380 
03381         char *data = o.str();
03382         StringElem  *se = new StringElem( data );
03383         delete data;
03384 
03385         text_list().ins_last( se );
03386 
03387         for (Mutator<StringElem> se_iter = text_list(); 
03388                                   se_iter.valid(); ++se_iter) {
03389             List<StringElem> &d 
03390                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03391             d.ins_last( se_iter.grab() );
03392         }
03393     }
03394 }
03395 
03396 void
03397 Directive::generate_csrd_test_monotone_directive( Statement &s, Assertion &a )
03398 {
03399     p_assert( a.type() == AS_TEST_MONOTONE, "not a test monotone assertion" );
03400 
03401     AssertTestMonotone &ap = (AssertTestMonotone &) a;
03402 
03403     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03404      iter.valid();
03405      ++iter) {
03406     
03407     AbstractAccess & aa = iter.current();
03408 
03409         strstream   o;
03410 
03411         o << "CSRD$ TEST_MONOTONE ";
03412     String name = aa.symbol().name_ref();
03413     o << name << " : ";
03414 
03415     if (!(aa.exec_predicate_true())) {
03416         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03417     }
03418 
03419     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03420          ad_iter.valid();
03421          ++ad_iter)
03422         {
03423         AccessDimension & ad = ad_iter.current();
03424         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03425         }
03426 
03427     o << " + " << aa.start_guarded();
03428 
03429         o << '\0';
03430 
03431         char *data = o.str();
03432         StringElem  *se = new StringElem( data );
03433         delete data;
03434 
03435         text_list().ins_last( se );
03436 
03437         for (Mutator<StringElem> se_iter = text_list(); 
03438                                   se_iter.valid(); ++se_iter) {
03439             List<StringElem> &d 
03440                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03441             d.ins_last( se_iter.grab() );
03442         }
03443     }
03444 }
03445 
03446 void
03447 Directive::generate_csrd_reduct_descr_directive( Statement &s, Assertion &a )
03448 {
03449     p_assert( a.type() == AS_REDUCT_DESCR, "not a reduct descriptor assertion" );
03450 
03451     AssertReductDescr &ap = (AssertReductDescr &) a;
03452 
03453     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03454      iter.valid();
03455      ++iter) {
03456     
03457     AbstractAccess & aa = iter.current();
03458 
03459         strstream   o;
03460 
03461         o << "CSRD$ REDUCTION_DESCR ";
03462     String name = aa.symbol().name_ref();
03463     o << name << " : ";
03464 
03465     if (!(aa.exec_predicate_true())) {
03466         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03467     }
03468 
03469     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03470          ad_iter.valid();
03471          ++ad_iter)
03472         {
03473         AccessDimension & ad = ad_iter.current();
03474         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03475         }
03476 
03477     o << " + " << aa.start_guarded();
03478 
03479         o << '\0';
03480 
03481         char *data = o.str();
03482         StringElem  *se = new StringElem( data );
03483         delete data;
03484 
03485         text_list().ins_last( se );
03486 
03487         for (Mutator<StringElem> se_iter = text_list(); 
03488                                   se_iter.valid(); ++se_iter) {
03489             List<StringElem> &d 
03490                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03491             d.ins_last( se_iter.grab() );
03492         }
03493     }
03494 }
03495 
03496 void
03497 Directive::generate_csrd_dep_overlap_directive( Statement &s, Assertion &a )
03498 {
03499     p_assert( a.type() == AS_DEP_OVERLAP, "not a dep overlap assertion" );
03500 
03501     AssertDepOverlap &ap = (AssertDepOverlap &) a;
03502 
03503     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03504      iter.valid();
03505      ++iter) {
03506     
03507     AbstractAccess & aa = iter.current();
03508 
03509         strstream   o;
03510 
03511         o << "CSRD$ DEP_OVERLAP ";
03512     String name = aa.symbol().name_ref();
03513     o << name << " : ";
03514 
03515     if (!(aa.exec_predicate_true())) {
03516         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03517     }
03518 
03519     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03520          ad_iter.valid();
03521          ++ad_iter)
03522         {
03523         AccessDimension & ad = ad_iter.current();
03524         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03525         }
03526 
03527     o << " + " << aa.start_guarded();
03528 
03529         o << '\0';
03530 
03531         char *data = o.str();
03532         StringElem  *se = new StringElem( data );
03533         delete data;
03534 
03535         text_list().ins_last( se );
03536 
03537         for (Mutator<StringElem> se_iter = text_list(); 
03538                                   se_iter.valid(); ++se_iter) {
03539             List<StringElem> &d 
03540                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03541             d.ins_last( se_iter.grab() );
03542         }
03543     }
03544 }
03545 
03546 
03547 void
03548 Directive::generate_csrd_dep_ROvsRW_directive( Statement &s, Assertion &a )
03549 {
03550     p_assert( a.type() == AS_DEP_RO_RW, "not a dep ROvsRW assertion" );
03551 
03552     AssertDepROvsRW &ap = (AssertDepROvsRW &) a;
03553 
03554     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03555      iter.valid();
03556      ++iter) {
03557     
03558     AbstractAccess & aa = iter.current();
03559 
03560         strstream   o;
03561 
03562         o << "CSRD$ DEP_RO_VS_RW ";
03563     String name = aa.symbol().name_ref();
03564     o << name << ":";
03565 
03566     if (!(aa.exec_predicate_true())) {
03567         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03568     }
03569 
03570     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03571          ad_iter.valid();
03572          ++ad_iter)
03573         {
03574         AccessDimension & ad = ad_iter.current();
03575         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03576         }
03577 
03578     o << " + " << aa.start_guarded();
03579 
03580         o << '\0';
03581 
03582         char *data = o.str();
03583         StringElem  *se = new StringElem( data );
03584         delete data;
03585 
03586         text_list().ins_last( se );
03587 
03588         for (Mutator<StringElem> se_iter = text_list(); 
03589                                   se_iter.valid(); ++se_iter) {
03590             List<StringElem> &d 
03591                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03592             d.ins_last( se_iter.grab() );
03593         }
03594     }
03595 }
03596 
03597 
03598 void
03599 Directive::generate_csrd_dep_RWvsWF_directive( Statement &s, Assertion &a )
03600 {
03601     p_assert( a.type() == AS_DEP_RW_WF, "not a dep RWvsWF assertion" );
03602 
03603     AssertDepRWvsWF &ap = (AssertDepRWvsWF &) a;
03604 
03605     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03606      iter.valid();
03607      ++iter) {
03608     
03609     AbstractAccess & aa = iter.current();
03610 
03611         strstream   o;
03612 
03613         o << "CSRD$ DEP_RW_VS_WF ";
03614     String name = aa.symbol().name_ref();
03615     o << name << " : ";
03616 
03617     if (!(aa.exec_predicate_true())) {
03618         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03619     }
03620 
03621     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03622          ad_iter.valid();
03623          ++ad_iter)
03624         {
03625         AccessDimension & ad = ad_iter.current();
03626         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03627         }
03628 
03629     o << " + " << aa.start_guarded();
03630 
03631         o << '\0';
03632 
03633         char *data = o.str();
03634         StringElem  *se = new StringElem( data );
03635         delete data;
03636 
03637         text_list().ins_last( se );
03638 
03639         for (Mutator<StringElem> se_iter = text_list(); 
03640                                   se_iter.valid(); ++se_iter) {
03641             List<StringElem> &d 
03642                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03643             d.ins_last( se_iter.grab() );
03644         }
03645     }
03646 }
03647 
03648 
03649 void
03650 Directive::generate_csrd_dep_WFvsRO_directive( Statement &s, Assertion &a )
03651 {
03652     p_assert( a.type() == AS_DEP_WF_RO, "not a dep WFvsRO assertion" );
03653 
03654     AssertDepWFvsRO &ap = (AssertDepWFvsRO &) a;
03655 
03656     for (Iterator<AbstractAccess> iter = ap.descr_list_guarded();
03657      iter.valid();
03658      ++iter) {
03659     
03660     AbstractAccess & aa = iter.current();
03661 
03662         strstream   o;
03663 
03664         o << "CSRD$ DEP_WF_VS_RO ";
03665     String name = aa.symbol().name_ref();
03666     o << name << " : ";
03667 
03668     if (!(aa.exec_predicate_true())) {
03669         o << "{" << *aa.pgm_summarized_to()->pred_repos().predicate(aa.exec_predicate()) << "}";
03670     }
03671 
03672     for (Iterator<AccessDimension> ad_iter = aa.iter_dims();
03673          ad_iter.valid();
03674          ++ad_iter)
03675         {
03676         AccessDimension & ad = ad_iter.current();
03677         o << "<" << ad.stride_guarded() << ", " << ad.span_guarded() << ">";
03678         }
03679 
03680     o << " + " << aa.start_guarded();
03681 
03682         o << '\0';
03683 
03684         char *data = o.str();
03685         StringElem  *se = new StringElem( data );
03686         delete data;
03687 
03688         text_list().ins_last( se );
03689 
03690         for (Mutator<StringElem> se_iter = text_list(); 
03691                                   se_iter.valid(); ++se_iter) {
03692             List<StringElem> &d 
03693                 = CASTAWAY(List<StringElem> &) s.pre_directives();
03694             d.ins_last( se_iter.grab() );
03695         }
03696     }
03697 }
03698