Ignore:
Timestamp:
Oct 18, 2014, 5:43:45 PM (5 years ago)
Author:
nmedfort
Message:

Big update to use CC_NameMap; removed CharClass? and RE_Reducer.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp

    r4247 r4249  
    1515#include <re/re_rep.h>
    1616#include <re/re_name.h>
     17#include <re/printer_re.h>
     18#include <cc/cc_namemap.hpp>
    1719
    1820#include <utility>
     
    4143}
    4244
    43 void CC_Compiler::compile(const RENameMap & re_map) {
    44     for (auto i =  re_map.cbegin(); i != re_map.cend(); ++i) {
    45         if (const CC * cc = dyn_cast<CC>(i->second)) {
    46             // If we haven't already computed this CC, map it to the (pablo) charset statements.
    47             if (mComputedSet.insert(cc->getName()).second) {
    48                 mCG.createAssign(cc->getName(), charset_expr(cc));
    49             }
    50         }
    51         else if (const Seq* seq = dyn_cast<Seq>(i->second)) {
    52             //This is specifically for the utf8 multibyte character classes.
    53             assert (seq->getType() == Seq::Type::Byte);
    54             Assign * assignment = nullptr;
    55             auto j = seq->begin();
    56             while (true) {
    57                 Name * name = dyn_cast<Name>(*j);
    58                 assert (name);
    59                 CharClass * cc = mCG.createCharClass(name->getName());
    60                 PabloAST * sym = assignment ? mCG.createAnd(mCG.createVar(assignment->getName()), cc) : cc;
    61                 if (++j != seq->end()) {
    62                     assignment = mCG.createAssign(mCG.ssa("marker"), mCG.createAdvance(sym));
    63                     continue;
    64                 }
    65                 mCG.createAssign(seq->getName(), sym);
    66                 break;
    67             }
    68         }
    69     }
    70 }
    71 
    72 inline PabloAST * CC_Compiler::charset_expr(const CC * cc) {
     45void CC_Compiler::compile(const CC_NameMap & nameMap) {
     46    for (Name * name : nameMap) {
     47        compile_re(name);
     48    }
     49}
     50
     51PabloAST * CC_Compiler::compile_re(RE * re) {
     52    if (isa<Name>(re)) {
     53        return compile_re(cast<Name>(re));
     54    }
     55    else if (isa<Alt>(re)) {
     56        return compile_re(cast<Alt>(re));
     57    }
     58    else if (isa<Seq>(re)) {
     59        return compile_re(cast<Seq>(re));
     60    }
     61    else if (isa<CC>(re)) {
     62
     63    }
     64    throw std::runtime_error("Unexpected RE node given to CC_Compiler: " + Printer_RE::PrintRE(re));
     65}
     66
     67PabloAST * CC_Compiler::compile_re(Name * name) {
     68    assert(name);
     69    Var * var = name->getVar();
     70    if (var == nullptr) {       
     71        if (name->getType() == Name::Type::FixedLength) {
     72            RE * cc = name->getCC();
     73            assert (cc);
     74            PabloAST * value = nullptr;
     75            if (isa<CC>(cc)) {
     76                value = charset_expr(cast<CC>(cc));
     77            }
     78            else if (isa<Seq>(cc)) {
     79                value = compile_re(cast<Seq>(cc));
     80            }
     81            else if (isa<Alt>(cc)) {
     82                value = compile_re(cast<Alt>(cc));
     83            }
     84            if (value == nullptr) {
     85                throw std::runtime_error("Unexpected CC node given to CC_Compiler: " + Printer_RE::PrintRE(name) + " : " + Printer_RE::PrintRE(cc));
     86            }
     87            mCG.createAssign(name->getName(), value);
     88        }
     89        var = mCG.createVar(name->getName());
     90        name->setVar(var);
     91    }
     92    return var;
     93}
     94
     95PabloAST * CC_Compiler::compile_re(const Seq * seq) {
     96    Assign * assignment = nullptr;
     97    PabloAST * result = nullptr;
     98    auto i = seq->begin();
     99    while (true) {
     100        PabloAST * cc = compile_re(*i);
     101        result = assignment ? mCG.createAnd(mCG.createVar(assignment), cc) : cc;
     102        if (++i == seq->end()) {
     103            break;
     104        }
     105        assignment = mCG.createAssign(mCG.ssa("seq"), mCG.createAdvance(result));
     106    }
     107    return result;
     108}
     109
     110PabloAST * CC_Compiler::compile_re(const Alt *alt) {
     111    Assign * assignment = nullptr;
     112    PabloAST * result = nullptr;
     113    auto i = alt->begin();
     114    while (true) {
     115        PabloAST * cc = compile_re(*i);
     116        result = assignment ? mCG.createOr(mCG.createVar(assignment), cc) : cc;
     117        if (++i == alt->end()) {
     118            break;
     119        }
     120        assignment = mCG.createAssign(mCG.ssa("alt"), result);
     121    }
     122    return result;
     123}
     124
     125
     126PabloAST * CC_Compiler::charset_expr(const CC * cc) {
    73127    if (cc->empty()) {
    74128        return mCG.createZeroes();
     
    103157                    bit0 = mCG.createNot(bit0);
    104158                }
    105                 return mCG.createAnd(expr, bit0);
     159                return tempify(mCG.createAnd(expr, bit0));
    106160            }
    107161        }
     
    110164    for (const CharSetItem & item : *cc) {
    111165        PabloAST * temp = char_or_range_expr(item.lo_codepoint, item.hi_codepoint);
    112         expr = (expr == nullptr) ? temp : mCG.createOr(expr, temp);
     166        expr = (expr == nullptr) ? temp : tempify(mCG.createOr(expr, temp));
    113167    }
    114168    return expr;
     
    150204    {
    151205        std::vector<PabloAST*> new_terms;
    152         for (unsigned long i = 0; i < (bit_terms.size()/2); i++)
    153         {
    154             new_terms.push_back(mCG.createAnd(bit_terms[(2 * i) + 1], bit_terms[2 * i]));
     206        for (auto i = 0; i < (bit_terms.size()/2); i++)
     207        {
     208            new_terms.push_back(tempify(mCG.createAnd(bit_terms[(2 * i) + 1], bit_terms[2 * i])));
    155209        }
    156210        if (bit_terms.size() % 2 == 1)
     
    158212            new_terms.push_back(bit_terms[bit_terms.size() -1]);
    159213        }
    160         bit_terms.assign(new_terms.begin(), new_terms.end());
     214        bit_terms.swap(new_terms);
    161215    }
    162216    return bit_terms[0];
    163217}
    164218
    165 PabloAST * CC_Compiler::char_test_expr(const CodePointType ch)
     219inline PabloAST * CC_Compiler::char_test_expr(const CodePointType ch)
    166220{
    167221    return bit_pattern_expr(ch, mEncoding.getMask());
     
    190244    PabloAST* hi_test = LE_Range(diff_count - 1, n2 & mask1);
    191245
    192     return mCG.createAnd(common, mCG.createSel(getBasisVar(diff_count - 1), hi_test, lo_test));
     246    return tempify(mCG.createAnd(common, mCG.createSel(getBasisVar(diff_count - 1), hi_test, lo_test)));
    193247}
    194248
    195249PabloAST * CC_Compiler::GE_Range(const unsigned N, const unsigned n) {
    196     if (N == 0)
    197     {
     250    if (N == 0) {
    198251        return mCG.createOnes(); //Return a true literal.
    199252    }
    200     else if (((N % 2) == 0) && ((n >> (N - 2)) == 0))
    201     {
    202         return mCG.createOr(mCG.createOr(getBasisVar(N - 1), getBasisVar(N - 2)), GE_Range(N - 2, n));
    203     }
    204     else if (((N % 2) == 0) && ((n >> (N - 2)) == 3))
    205     {
    206         return mCG.createAnd(mCG.createAnd(getBasisVar(N - 1), getBasisVar(N - 2)), GE_Range(N - 2, n - (3 << (N - 2))));
     253    else if (((N % 2) == 0) && ((n >> (N - 2)) == 0)) {
     254        return tempify(mCG.createOr(tempify(mCG.createOr(getBasisVar(N - 1), getBasisVar(N - 2))), GE_Range(N - 2, n)));
     255    }
     256    else if (((N % 2) == 0) && ((n >> (N - 2)) == 3)) {
     257        return tempify(mCG.createAnd(tempify(mCG.createAnd(getBasisVar(N - 1), getBasisVar(N - 2))), GE_Range(N - 2, n - (3 << (N - 2)))));
    207258    }
    208259    else if (N >= 1)
     
    218269              the value of GE_range(N-1), lo_range) is required.
    219270            */
    220             return mCG.createOr(getBasisVar(N - 1), lo_range);
     271            return tempify(mCG.createOr(getBasisVar(N - 1), lo_range));
    221272        }
    222273        else
     
    226277              in the target for >= and GE_range(N-1, lo_bits) must also be true.
    227278            */
    228             return mCG.createAnd(getBasisVar(N - 1), lo_range);
     279            return tempify(mCG.createAnd(getBasisVar(N - 1), lo_range));
    229280        }
    230281    }
     
    242293    }
    243294    else {
    244         return mCG.createNot(GE_Range(N, n + 1));
     295        return tempify(mCG.createNot(GE_Range(N, n + 1)));
    245296    }
    246297}
     
    260311}
    261312
     313inline PabloAST * CC_Compiler::tempify(PabloAST * value) {
     314//    if (isa<Var>(value)) {
     315//        return cast<Var>(value);
     316//    }
     317//    return mCG.createVar(mCG.createAssign(mCG.ssa("t"), value));
     318    return value;
     319}
     320
    262321} // end of namespace cc
Note: See TracChangeset for help on using the changeset viewer.