Ignore:
Timestamp:
Nov 14, 2015, 5:38:36 PM (4 years ago)
Author:
nmedfort
Message:

Bug fix for Multiplexing. Added ability to set the body of a If/While? node after creation.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r4797 r4870  
    55 */
    66
    7 #include <pablo/printer_pablos.h>
     7#include "printer_pablos.h"
     8#include <pablo/codegenstate.h>
     9#include <llvm/Support/raw_os_ostream.h>
    810#include <iostream>
    9 #include <ostream>
    10 #include <llvm/Support/raw_os_ostream.h>
    1111
    12 //Regular Expressions
    13 #include <re/re_re.h>
    14 #include <re/re_cc.h>
    15 #include <re/re_start.h>
    16 #include <re/re_end.h>
    17 #include <re/re_seq.h>
    18 #include <re/re_name.h>
    19 
    20 //Pablo Expressions
    21 #include <pablo/pabloAST.h>
    22 #include <pablo/pe_advance.h>
    23 #include <pablo/pe_and.h>
    24 #include <pablo/pe_call.h>
    25 #include <pablo/pe_matchstar.h>
    26 #include <pablo/pe_not.h>
    27 #include <pablo/pe_or.h>
    28 #include <pablo/pe_scanthru.h>
    29 #include <pablo/pe_sel.h>
    30 #include <pablo/pe_var.h>
    31 #include <pablo/pe_xor.h>
    32 #include <pablo/ps_assign.h>
    33 #include <pablo/ps_if.h>
    34 #include <pablo/ps_while.h>
    35 #include <pablo/pe_zeroes.h>
    36 #include <pablo/pe_ones.h>
    37 #include <pablo/codegenstate.h>
    38 
    39 using namespace re;
    4012using namespace pablo;
    4113
    42 void PabloPrinter::print(const PabloBlock & block, llvm::raw_ostream & strm)
    43 {
    44     print(block.statements(), "  ", strm);
     14const unsigned BlockIndenting = 2;
     15
     16void PabloPrinter::print(const pablo::PabloFunction & function, llvm::raw_ostream & out) {
     17    print(function.getEntryBlock(), out, true);
    4518}
    4619
    47 void PabloPrinter::print(const StatementList & stmts, llvm::raw_ostream & strm) {
    48     print(stmts, "  ", strm);
     20inline void print_vars(const pablo::If::DefinedVars & vars, llvm::raw_ostream & out, const unsigned indent) {
     21    for (const Assign * def : vars) {
     22        out.indent(indent);
     23        out << def->getName() << " = 0\n";
     24    }
    4925}
    5026
    51 void PabloPrinter::print(const StatementList & stmts, std::string indent, llvm::raw_ostream & strm) {
    52     for (const Statement * stmt : stmts) {
    53         print(stmt, indent, strm);
     27void PabloPrinter::print(const Statement * stmt, llvm::raw_ostream & out, const bool expandNested, const unsigned indent) {
     28    out.indent(indent);
     29    if (stmt == nullptr) {
     30        out << "<null-stmt>";
     31    } else if (const Assign * an = dyn_cast<const Assign>(stmt)) {
     32        out << an->getName() << " = ";
     33        print(an->getExpression(), out);
     34    } else if (const Next * next = dyn_cast<const Next>(stmt)) {
     35        out << "Next(" << next->getName() << ") = ";
     36        print(next->getExpr(), out);
     37    } else if (const If * ifstmt = dyn_cast<const If>(stmt)) {
     38        out << "if ";
     39        print(ifstmt->getCondition(), out);
     40        if (expandNested) {
     41            out << ":\n";
     42            print(ifstmt->getBody(), out, true, indent + BlockIndenting);
     43            out.indent(indent);
     44            out << "else:\n";
     45            print_vars(ifstmt->getDefined(), out, indent + BlockIndenting);
     46        }
     47    } else if (const While * whileNode = dyn_cast<const While>(stmt)) {
     48        out << "while ";
     49        print(whileNode->getCondition(), out);
     50        if (expandNested) {
     51            out << ":\n";
     52            print(whileNode->getBody(), out, true, indent + BlockIndenting);
     53        }
     54    } else if (const Call * call = dyn_cast<const Call>(stmt)) {
     55        out << " = " << call->getCallee() << "()";
     56    } else if (const And * pablo_and = dyn_cast<const And>(stmt)) {
     57        out << pablo_and->getName() << " = (";
     58        print(pablo_and->getExpr1(), out);
     59        out << " & ";
     60        print(pablo_and->getExpr2(), out);
     61        out << ")";
     62    } else if (const Or * pablo_or = dyn_cast<const Or>(stmt)) {
     63        out << pablo_or->getName() << " = (";
     64        print(pablo_or->getExpr1(), out);
     65        out << " | ";
     66        print(pablo_or->getExpr2(), out);
     67        out << ")";
     68    } else if (const Xor * pablo_xor = dyn_cast<const Xor>(stmt)) {
     69        out << pablo_xor->getName() << " = (";
     70        print(pablo_xor->getExpr1(), out);
     71        out << " ^ ";
     72        print(pablo_xor->getExpr2(), out);
     73        out << ")";
     74    } else if (const Sel * pablo_sel = dyn_cast<const Sel>(stmt)) {
     75        out << pablo_sel->getName() << " = (";
     76        print(pablo_sel->getCondition(), out);
     77        out << " ? ";
     78        print(pablo_sel->getTrueExpr(), out);
     79        out << " : ";
     80        print(pablo_sel->getFalseExpr(), out);
     81        out << ")";
     82    } else if (const Not * pablo_not = dyn_cast<const Not>(stmt)) {
     83        out << pablo_not->getName() << " = (~";
     84        print(pablo_not->getExpr(), out);
     85        out << ")";
     86    } else if (const Advance * adv = dyn_cast<const Advance>(stmt)) {
     87        out << adv->getName() << " = pablo.Advance(";
     88        print(adv->getExpr(), out);
     89        out << ", " << std::to_string(adv->getAdvanceAmount()) << ")";
     90    } else if (const MatchStar * mstar = dyn_cast<const MatchStar>(stmt)) {
     91        out << mstar->getName() << " = pablo.MatchStar(";
     92        print(mstar->getMarker(), out);
     93        out << ", ";
     94        print(mstar->getCharClass(), out);
     95        out << ")";
     96    } else if (const ScanThru * sthru = dyn_cast<const ScanThru>(stmt)) {
     97        out << sthru->getName() << " = pablo.ScanThru(";
     98        print(sthru->getScanFrom(), out);
     99        out << ", ";
     100        print(sthru->getScanThru(), out);
     101        out << ")";
     102    } else if (const Mod64Advance * adv = dyn_cast<const Mod64Advance>(stmt)) {
     103        out << adv->getName() << " = pablo.Mod64Advance(";
     104        print(adv->getExpr(), out);
     105        out << ", " << std::to_string(adv->getAdvanceAmount()) << ")";
     106    } else if (const Mod64MatchStar * mstar = dyn_cast<const Mod64MatchStar>(stmt)) {
     107        out << mstar->getName() << " = pablo.Mod64MatchStar(";
     108        print(mstar->getMarker(), out);
     109        out << ", ";
     110        print(mstar->getCharClass(), out);
     111        out << ")";
     112    } else if (const Mod64ScanThru * sthru = dyn_cast<const Mod64ScanThru>(stmt)) {
     113        out << sthru->getName() << " = pablo.Mod64ScanThru(";
     114        print(sthru->getScanFrom(), out);
     115        out << ", ";
     116        print(sthru->getScanThru(), out);
     117        out << ")";
     118    } else if (const Count * count = dyn_cast<const Count>(stmt)) {
     119        out << count->getName() << " = pablo.Count(";
     120        print(count->getExpr(), out);
     121        out << ")";
     122    } else {
     123        out << "???";
     124    }
     125}
     126
     127void PabloPrinter::print(const PabloAST * expr, llvm::raw_ostream & out) {
     128    if (expr == nullptr) {
     129        out << "<null-expr>";
     130    } else if (isa<const Zeroes>(expr)) {
     131        out << "0";
     132    } else if (isa<const Ones>(expr)) {
     133        out << "1";
     134    } else if (const Var * var = dyn_cast<const Var>(expr)) {
     135        out  << var->getName();
     136    } else if (const Next * next = dyn_cast<const Next>(expr)) {
     137        out << "Next(" << next->getName() << ")";
     138    } else if (const If * ifstmt = dyn_cast<If>(expr)) {
     139        out << "If ";
     140        print(ifstmt->getCondition(), out);
     141    } else if (const While * whl = dyn_cast<While>(expr)) {
     142        out << "While ";
     143        print(whl->getCondition(), out);
     144    } else if (const Statement * stmt = dyn_cast<Statement>(expr)) {
     145        out << stmt->getName();
     146    } else if (isa<Integer>(expr)) {
     147        out << cast<Integer>(expr)->value();
     148    } else {
     149        out << "???";
     150    }
     151}
     152
     153void PabloPrinter::print(const PabloBlock * block, llvm::raw_ostream & strm, const bool expandNested, const unsigned indent) {
     154    for (const Statement * stmt : *block) {
     155        print(stmt, strm, expandNested, indent);
    54156        strm << "\n";
    55157    }
    56158}
    57159
    58 void PabloPrinter::print_vars(const DefinedVars & vars, std::string indent, llvm::raw_ostream & strm) {
    59     for (const PabloAST * v : vars) {
    60         strm << indent << dyn_cast<Assign>(v)->getName() << " = 0" << "\n";
    61     }
    62 }
    63160
    64 void PabloPrinter::print(const Statement * stmt, std::string indent, llvm::raw_ostream & strm) {
    65     strm << indent;
    66     if (stmt == nullptr) {
    67         strm << "<null-stmt>";
    68     }
    69     else if (const Assign * an = dyn_cast<const Assign>(stmt)) {
    70         strm << an->getName() << " = ";
    71         print(an->getExpression(), strm);
    72     }
    73     else if (const Next * next = dyn_cast<const Next>(stmt)) {       
    74         strm << "Next(" << next->getName() << ") = ";
    75         print(next->getExpr(), strm);
    76     }
    77     else if (const If * ifstmt = dyn_cast<const If>(stmt)) {
    78         strm << "if ";
    79         print(ifstmt->getCondition(), strm);
    80         strm << ":" << "\n";
    81         print(ifstmt->getBody(), indent + "  ", strm);
    82         strm << indent << "else:" << "\n";
    83         print_vars(ifstmt->getDefined(), indent + "  ", strm);
    84     }
    85     else if (const While * whl = dyn_cast<const While>(stmt)) {
    86         strm << "while ";
    87         print(whl->getCondition(), strm);
    88         strm << ":" << "\n";
    89         print(whl->getBody(), indent + "  ", strm);
    90     }
    91     else if (const Call * call = dyn_cast<const Call>(stmt)) {
    92         strm << " = " << call->getCallee() << "()";
    93     }
    94     else if (const And * pablo_and = dyn_cast<const And>(stmt)) {
    95         print(pablo_and, strm);
    96         strm << " = (";
    97         print(pablo_and->getExpr1(), strm);
    98         strm << " & ";
    99         print(pablo_and->getExpr2(), strm);
    100         strm << ")";
    101     }
    102     else if (const Or * pablo_or = dyn_cast<const Or>(stmt)) {
    103         print(pablo_or, strm);
    104         strm << " = (";
    105         print(pablo_or->getExpr1(), strm);
    106         strm << " | ";
    107         print(pablo_or->getExpr2(), strm);
    108         strm << ")";
    109     }
    110     else if (const Xor * pablo_xor = dyn_cast<const Xor>(stmt)) {
    111         print(pablo_xor, strm);
    112         strm << " = (";
    113         print(pablo_xor->getExpr1(), strm);
    114         strm << " ^ ";
    115         print(pablo_xor->getExpr2(), strm);
    116         strm << ")";
    117     }
    118     else if (const Sel * pablo_sel = dyn_cast<const Sel>(stmt)) {
    119         print(pablo_sel, strm);
    120         strm << " = (";
    121         print(pablo_sel->getCondition(), strm);
    122         strm << " ? ";
    123         print(pablo_sel->getTrueExpr(), strm);
    124         strm << " : ";
    125         print(pablo_sel->getFalseExpr(), strm);
    126         strm << ")";
    127     }
    128     else if (const Not * pablo_not = dyn_cast<const Not>(stmt)) {
    129         print(pablo_not, strm);
    130         strm << " = (~";
    131         print(pablo_not->getExpr(), strm);
    132         strm << ")";
    133     }
    134     else if (const Advance * adv = dyn_cast<const Advance>(stmt)) {
    135         print(adv, strm);
    136         strm << " = pablo.Advance(";
    137         print(adv->getExpr(), strm);
    138         strm << ", " << std::to_string(adv->getAdvanceAmount()) << ")";
    139     }
    140     else if (const MatchStar * mstar = dyn_cast<const MatchStar>(stmt)) {
    141         print(mstar, strm);
    142         strm << " = pablo.MatchStar(";
    143         print(mstar->getMarker(), strm);
    144         strm << ", ";
    145         print(mstar->getCharClass(), strm);
    146         strm << ")";
    147     }
    148     else if (const ScanThru * sthru = dyn_cast<const ScanThru>(stmt)) {
    149         print(sthru, strm);
    150         strm << " = pablo.ScanThru(";
    151         print(sthru->getScanFrom(), strm);
    152         strm << ", ";
    153         print(sthru->getScanThru(), strm);
    154         strm << ")";
    155     }
    156     else if (const Mod64Advance * adv = dyn_cast<const Mod64Advance>(stmt)) {
    157         print(adv, strm);
    158         strm << " = pablo.Mod64Advance(";
    159         print(adv->getExpr(), strm);
    160         strm << ", " << std::to_string(adv->getAdvanceAmount()) << ")";
    161     }
    162     else if (const Mod64MatchStar * mstar = dyn_cast<const Mod64MatchStar>(stmt)) {
    163         print(mstar, strm);
    164         strm << " = pablo.Mod64MatchStar(";
    165         print(mstar->getMarker(), strm);
    166         strm << ", ";
    167         print(mstar->getCharClass(), strm);
    168         strm << ")";
    169     }
    170     else if (const Mod64ScanThru * sthru = dyn_cast<const Mod64ScanThru>(stmt)) {
    171         print(sthru, strm);
    172         strm << " = pablo.Mod64ScanThru(";
    173         print(sthru->getScanFrom(), strm);
    174         strm << ", ";
    175         print(sthru->getScanThru(), strm);
    176         strm << ")";
    177     }
    178     else if (const Count * pablo_not = dyn_cast<const Count>(stmt)) {
    179         print(pablo_not, strm);
    180         strm << " = pablo.Count(";
    181         print(pablo_not->getExpr(), strm);
    182         strm << ")";
    183     }
    184     else {
    185         strm << "???";
    186     }
    187 }
    188 
    189 void PabloPrinter::print(const PabloAST * expr, llvm::raw_ostream & strm) {
    190     if (expr == nullptr) {
    191         strm << "<null-expr>";
    192     } else if (isa<const Zeroes>(expr)) {
    193         strm << "0";
    194     } else if (isa<const Ones>(expr)) {
    195         strm << "1";
    196     } else if (const Var * var = dyn_cast<const Var>(expr)) {
    197         assert (var->getName());
    198         strm  << var->getName();
    199     } else if (const Next * next = dyn_cast<const Next>(expr)) {
    200         assert (next->getName());
    201         strm << "Next(" << next->getName() << ")";
    202     } else if (const If * ifstmt = dyn_cast<If>(expr)) {
    203         strm << "if ";
    204         print(ifstmt->getCondition(), strm);
    205     } else if (const While * whl = dyn_cast<While>(expr)) {
    206         strm << "while ";
    207         print(whl->getCondition(), strm);
    208     } else if (const Statement * stmt = dyn_cast<Statement>(expr)) {
    209         assert (stmt->getName());
    210         strm << stmt->getName();
    211     } else if (isa<Integer>(expr)) {
    212         strm << cast<Integer>(expr)->value();
    213     } else {
    214         strm << "???";
    215     }
    216 }
    217 
    218 
Note: See TracChangeset for help on using the changeset viewer.