Ignore:
Timestamp:
Sep 30, 2014, 2:44:40 PM (5 years ago)
Author:
nmedfort
Message:

Replaced dynamic_cast with llvm::dyn_cast in pablo code; implemented make functions for pablo constructors. Disabled RTTI.

File:
1 edited

Legend:

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

    r4199 r4200  
    99
    1010//Pablo Expressions
    11 #include <pablo/pablo_routines.h>
    1211#include <pablo/ps_pablos.h>
    1312#include <pablo/pe_advance.h>
     
    7574{   
    7675    //Add the new mapping to the list of pablo statements:
    77     mStmtsl.push_back(new Assign(varname, expr->pablo_expr));
     76    mStmtsl.push_back(make_assign(varname, expr->pablo_expr));
    7877
    7978    //Add the new mapping to the common expression map:
     
    8180    Expression* mapped_value = new Expression();
    8281    mapped_value->expr_string = varname;
    83     mapped_value->pablo_expr = new Var(varname);
     82    mapped_value->pablo_expr = make_var(varname);
    8483
    8584    std::pair<MapIterator, bool> ret = mCommon_Expression_Map.insert(make_pair(key_value, mapped_value));
     
    105104
    106105
    107 std::string CC_Compiler::compile1(CC* cc)
     106std::string CC_Compiler::compile1(CC * cc)
    108107{
    109108  cc2pablos(cc);
     
    122121}
    123122
    124 void CC_Compiler::process_re(const RE* re) {
     123void CC_Compiler::process_re(const RE * re) {
    125124    if (const Alt* re_alt = dyn_cast<const Alt>(re)) {
    126125        for (const RE * re : *re_alt) {
     
    143142PabloE* CC_Compiler::bit_pattern_expr(int pattern, int selected_bits)
    144143{
    145     if (selected_bits == 0) return new All(1);
     144    if (selected_bits == 0) return make_all(1);
    146145
    147146    std::vector<PabloE*> bit_terms;
     
    164163        else
    165164        {
    166             bit_terms.push_back(new All(1));
     165            bit_terms.push_back(make_all(1));
    167166        }
    168167        selected_bits &= ~test_bit;
     
    218217}
    219218
    220 PabloE* CC_Compiler::GE_Range(int N, int n)
    221 {
     219PabloE * CC_Compiler::GE_Range(int N, int n) {
    222220    if (N == 0)
    223221    {
    224         return new All(1); //Return a true literal.
     222        return make_all(1); //Return a true literal.
    225223    }
    226224    else if (((N % 2) == 0) && ((n >> (N - 2)) == 0))
    227225    {
    228         return make_or(make_or(make_bitv(N-1), make_bitv(N-2)), GE_Range(N-2, n));
     226        return make_or(make_or(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n));
    229227    }
    230228    else if (((N % 2) == 0) && ((n >> (N - 2)) == 3))
    231229    {
    232         return make_and(make_and(make_bitv(N-1), make_bitv(N-2)), GE_Range(N-2, n-(3<<(N-2))));
    233     }
    234     else if(N >= 1)
     230        return make_and(make_and(make_bitv(N - 1), make_bitv(N - 2)), GE_Range(N - 2, n - (3 << (N - 2))));
     231    }
     232    else if (N >= 1)
    235233    {
    236234        int hi_bit = n & (1 << (N-1));
     
    255253        }
    256254    }
    257     else
    258     {
    259         return 0;
    260     }
    261 }
    262 
    263 PabloE* CC_Compiler::LE_Range(int N, int n)
     255    throw std::runtime_error("Unexpected input given to ge_range: " + std::to_string(N) + ", " + std::to_string(n));
     256}
     257
     258PabloE * CC_Compiler::LE_Range(int N, int n)
    264259{
    265260    /*
     
    268263    */
    269264    if ((n + 1) == (1 << N)) {
    270         return new All(1); //True.
     265        return make_all(1); //True.
    271266    }
    272267    else {
     
    277272PabloE* CC_Compiler::charset_expr(const CC * cc) {
    278273    if (cc->empty()) {
    279         return new All(0);
     274        return make_all(0);
    280275    }
    281276    if (cc->size() > 2) {
     
    339334    Expression* retExpr = new Expression();
    340335
    341     if (All* all = dynamic_cast<All*>(expr))
     336    if (All * all = dyn_cast<All>(expr))
    342337    {
    343338        if (all->getValue() == 1)
    344339        {
    345340            retExpr->expr_string = "All(1)";
    346             retExpr->pablo_expr = new All(1);
     341            retExpr->pablo_expr = make_all(1);
    347342        }
    348343        else if (all->getValue() == 0)
    349344        {
    350345            retExpr->expr_string = "All(0)";
    351             retExpr->pablo_expr = new All(0);
    352         }
    353     }
    354     else if (Var * var = dynamic_cast<Var*>(expr))
     346            retExpr->pablo_expr = make_all(0);
     347        }
     348    }
     349    else if (Var * var = dyn_cast<Var>(expr))
    355350    {
    356351            retExpr->expr_string = var->getVar();
    357             retExpr->pablo_expr = new Var(var->getVar());
    358     }
    359     else if (Not* pe_not = dynamic_cast<Not*>(expr))
     352            retExpr->pablo_expr = make_var(var->getVar());
     353    }
     354    else if (Not * pe_not = dyn_cast<Not>(expr))
    360355    {
    361356        Expression* ret = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    362357        retExpr->expr_string =  "~" + ret->expr_string;
    363         retExpr->pablo_expr = new Not(ret->pablo_expr);
    364     }
    365     else if(Or* pe_or = dynamic_cast<Or*>(expr))
     358        retExpr->pablo_expr = make_not(ret->pablo_expr);
     359    }
     360    else if(Or * pe_or = dyn_cast<Or>(expr))
    366361    {
    367362        Expression* ret1 = expr_to_variable(expr2pabloe(pe_or->getExpr1()));
    368363        Expression* ret2 = expr_to_variable(expr2pabloe(pe_or->getExpr2()));
    369364        retExpr->expr_string = "(" + ret1->expr_string + "|" + ret2->expr_string + ")";
    370         retExpr->pablo_expr = new Or(ret1->pablo_expr, ret2->pablo_expr);
    371     }
    372     else if (Xor* pe_xor = dynamic_cast<Xor*>(expr))
     365        retExpr->pablo_expr = make_or(ret1->pablo_expr, ret2->pablo_expr);
     366    }
     367    else if (Xor * pe_xor = dyn_cast<Xor>(expr))
    373368    {
    374369        Expression* ret1 = expr_to_variable(expr2pabloe(pe_xor->getExpr1()));
    375370        Expression* ret2 = expr_to_variable(expr2pabloe(pe_xor->getExpr2()));
    376371        retExpr->expr_string = "(" + ret1->expr_string + "^" + ret2->expr_string + ")";
    377         retExpr->pablo_expr = new Xor(ret1->pablo_expr, ret2->pablo_expr);
    378     }
    379     else if (And* pe_and = dynamic_cast<And*>(expr))
    380     {
    381         if (Not* pe_not = dynamic_cast<Not*>(pe_and->getExpr1()))
     372        retExpr->pablo_expr = make_xor(ret1->pablo_expr, ret2->pablo_expr);
     373    }
     374    else if (And * pe_and = dyn_cast<And>(expr))
     375    {
     376        if (Not * pe_not = dyn_cast<Not>(pe_and->getExpr1()))
    382377        {
    383378            Expression* ret1 = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    384379            Expression* ret2 = expr_to_variable(expr2pabloe(pe_and->getExpr2()));
    385380            retExpr->expr_string = "(" + ret2->expr_string + "&~" + ret1->expr_string + ")";
    386             retExpr->pablo_expr = new And(ret2->pablo_expr, new Not(ret1->pablo_expr));
    387         }
    388         else if (Not* pe_not = dynamic_cast<Not*>(pe_and->getExpr2()))
     381            retExpr->pablo_expr = make_and(ret2->pablo_expr, make_not(ret1->pablo_expr));
     382        }
     383        else if (Not * pe_not = dyn_cast<Not>(pe_and->getExpr2()))
    389384        {
    390385            Expression* ret1 = expr_to_variable(expr2pabloe(pe_and->getExpr1()));
    391386            Expression* ret2 = expr_to_variable(expr2pabloe(pe_not->getExpr()));
    392387            retExpr->expr_string = "(" + ret1->expr_string  + "&~" + ret2->expr_string + ")";
    393             retExpr->pablo_expr = new And(ret1->pablo_expr, new Not(ret2->pablo_expr));
     388            retExpr->pablo_expr = make_and(ret1->pablo_expr, make_not(ret2->pablo_expr));
    394389        }
    395390        else
     
    398393            Expression* ret2 = expr_to_variable(expr2pabloe(pe_and->getExpr2()));
    399394            retExpr->expr_string = "(" + ret1->expr_string + "&" + ret2->expr_string + ")";
    400             retExpr->pablo_expr = new And(ret1->pablo_expr, ret2->pablo_expr);
    401         }
    402     }
    403     else if (Sel * pe_sel = dynamic_cast<Sel*>(expr))
     395            retExpr->pablo_expr = make_and(ret1->pablo_expr, ret2->pablo_expr);
     396        }
     397    }
     398    else if (Sel * pe_sel = dyn_cast<Sel>(expr))
    404399    {
    405400        Expression* ret_sel = expr_to_variable(expr2pabloe(pe_sel->getIf_expr()));
     
    408403        retExpr->expr_string = "((" + ret_sel->expr_string + "&" + ret_true->expr_string + ")|(~("
    409404            + ret_sel->expr_string + ")&" + ret_false->expr_string + ")";
    410         retExpr->pablo_expr = new Sel(ret_sel->pablo_expr, ret_true->pablo_expr, ret_false->pablo_expr);
     405        retExpr->pablo_expr = make_sel(ret_sel->pablo_expr, ret_true->pablo_expr, ret_false->pablo_expr);
    411406    }
    412407
     
    426421PabloE* CC_Compiler::make_bitv(int n)
    427422{
    428     return new Var(bit_var((mEncoding.getBits() - 1) - n));
     423    return make_var(bit_var((mEncoding.getBits() - 1) - n));
    429424}
    430425
Note: See TracChangeset for help on using the changeset viewer.