Changeset 4196


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

Bug fix for CC_Compiler

Location:
icGREP/icgrep-devel/icgrep
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/CMakeLists.txt

    r4187 r4196  
    4747message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
    4848
     49# Check if boost has been installed on this system.
     50set(Boost_USE_STATIC_LIBS ON)
     51set(Boost_USE_MULTITHREADED OFF) 
     52set(Boost_USE_STATIC_RUNTIME OFF)
     53include(FindBoost)
     54
    4955add_library(PabloADT pe_advance.cpp  pe_all.cpp  pe_and.cpp pe_call.cpp pe_charclass.cpp  pe_matchstar.cpp pe_scanthru.cpp pe_not.cpp  pe_or.cpp  pe_pabloe.cpp  pe_sel.cpp  pe_var.cpp  pe_xor.cpp ps_assign.cpp  ps_if.cpp  ps_pablos.cpp  ps_while.cpp printer_pablos.cpp)
    5056
    5157add_library(RegExpADT re/re_alt.cpp  re/re_cc.cpp  re/re_end.cpp  re/re_name.cpp re/re_parser.cpp  re/re_re.cpp  re/re_rep.cpp  re/re_seq.cpp re/re_start.cpp re/parsefailure.cpp  printer_re.cpp)
    5258
    53 
    54 #include_directories("${PROJECT_BINARY_DIR}")
    5559include_directories("${PROJECT_SOURCE_DIR}")
    5660include_directories("${PROJECT_SOURCE_DIR}/include")
     
    5862include_directories("${PROJECT_SOURCE_DIR}/include/simd-lib/idisa_cpp")
    5963
     64if (Boost_FOUND)
     65    include_directories(${Boost_INCLUDE_DIRS})
     66endif()
     67
    6068# add the executable
    6169add_executable(icgrep icgrep.cpp llvm_gen.cpp llvm_gen_helper.cpp utf_encoding.cpp cc_compiler.cpp  cc_compiler_helper.cpp re/re_simplifier.cpp re/re_reducer.cpp re/re_nullable.cpp re/re_compiler.cpp pbix_compiler.cpp  symbol_generator.cpp utf8_encoder.cpp unicode_categories.h unicode_categories-flat.h unicode_categories-simple.h)
    6270
    6371target_link_libraries (icgrep PabloADT RegExpADT ${REQ_LLVM_LIBRARIES})
     72if (Boost_FOUND)
     73    target_link_libraries (icgrep ${Boost_LIBRARIES})
     74endif()
     75
    6476
    6577#Check compiler support for 0x / 11
  • icGREP/icgrep-devel/icgrep/cc_compiler.cpp

    r4194 r4196  
    275275}
    276276
    277 PabloE* CC_Compiler::charset_expr(const CC * cc)
    278 {
     277PabloE* CC_Compiler::charset_expr(const CC * cc) {
    279278    if (cc->empty()) {
    280279        return new All(0);
    281280    }
    282 
    283     if (cc->size() > 1) {
     281    if (cc->size() > 2) {
    284282        bool combine = true;
    285283        for (const CharSetItem & item : *cc) {
     
    300298            }
    301299            if (combine) {
    302                 const CodePointType lo = cc->front().lo_codepoint;
    303                 const CodePointType hi = cc->back().lo_codepoint;
    304                 PabloE * expr = make_range(lo & 0xFE, hi | 0x01);
    305                 // should this be here? was in the prototype but not icgrep
    306                 expr = CC_Compiler_Helper::make_and(expr, new All((lo & 1) == 1 ? 0 : 1));
    307                 return expr;
     300                CodePointType lo = cc->front().lo_codepoint;
     301                CodePointType hi = cc->back().lo_codepoint;
     302                const CodePointType mask = mEncoding.getMask();
     303                lo &= (mask - 1);
     304                hi |= (mask ^ (mask - 1));
     305                PabloE * expr = make_range(lo, hi);
     306                PabloE * bit0 = make_bitv(0);
     307                if ((lo & 1) == 0) {
     308                    bit0 = CC_Compiler_Helper::make_not(bit0);
     309                }
     310                return CC_Compiler_Helper::make_and(expr, bit0);
    308311            }
    309312        }
     
    328331
    329332
    330 Expression* CC_Compiler::expr2pabloe(PabloE* expr)
    331 {
     333Expression* CC_Compiler::expr2pabloe(PabloE* expr) {
    332334    /*
    333335      Translate a Pablo Expression into three-address code using
  • icGREP/icgrep-devel/icgrep/cc_compiler_helper.cpp

    r4194 r4196  
    3636PabloE* CC_Compiler_Helper::make_not(PabloE* expr)
    3737{
    38     if (All* all = dynamic_cast<All*>(expr))
    39     {
     38    if (All* all = dynamic_cast<All*>(expr)) {
    4039        if (all->getNum() == 1) //If true literal.
    4140        {
     
    4746        }
    4847    }
    49     else if (Not* pe_not = dynamic_cast<Not*>(expr))
    50     {
    51         return pe_not->getExpr();
    52     }
    53     else
    54     {
     48    else if (Not* pe_not = dynamic_cast<Not*>(expr)) {
     49        PabloE * expr = pe_not->getExpr();
     50        pe_not->setExpr(nullptr);
     51        delete pe_not;
     52        return expr;
     53    }
     54    else {
    5555        return new Not(expr);
    5656    }
    5757}
    5858
    59 PabloE* CC_Compiler_Helper::make_and(PabloE *expr1, PabloE *expr2)
    60 {
    61     if (All* all = dynamic_cast<All*>(expr1))
    62     {
    63         if (all->getNum() == 1)
    64         {
     59PabloE* CC_Compiler_Helper::make_and(PabloE * expr1, PabloE *expr2)
     60{
     61    if (All* all = dynamic_cast<All*>(expr1)) {
     62        if (all->getNum() == 1) {
     63            delete all;
    6564            return expr2;
    6665        }
    67         else //if (all->getNum() == 0)
    68         {
     66        else { //if (all->getNum() == 0)
     67            delete expr1;
     68            delete expr2;
    6969            return new All(0);
    7070        }
    7171    }
    72     else if (All* all = dynamic_cast<All*>(expr2))
    73     {
    74         if (all->getNum() == 1)
    75         {
     72    else if (All* all = dynamic_cast<All*>(expr2)) {
     73        if (all->getNum() == 1) {
     74            delete expr2;
    7675            return expr1;
    7776        }
    78         else //if (all->getNum() == 0)
    79         {
     77        else { //if (all->getNum() == 0)
     78            delete expr1;
     79            delete expr2;
    8080            return new All(0);
    8181        }
    8282    }
    83     else if (equal_exprs(expr1, expr2))
    84     {
     83    else if (equal_exprs(expr1, expr2)) {
     84        delete expr2;
    8585        return expr1;
    8686    }
    87     else if (Not* pe_not_e1 = dynamic_cast<Not*>(expr1))
    88     {
    89         if (Not* pe_not_e2 = dynamic_cast<Not*>(expr2))
    90         {
    91             return make_not(make_or(pe_not_e1->getExpr(), pe_not_e2->getExpr()));
    92         }
    93         else if (equal_exprs(pe_not_e1->getExpr(), expr2))
    94         {
     87    else if (Not* pe_not_e1 = dynamic_cast<Not*>(expr1)) {
     88        if (Not* pe_not_e2 = dynamic_cast<Not*>(expr2)) {
     89
     90            PabloE * e1 = pe_not_e1->getExpr();
     91            pe_not_e1->setExpr(nullptr);
     92            delete pe_not_e1;
     93
     94            PabloE * e2 = pe_not_e2->getExpr();
     95            pe_not_e2->setExpr(nullptr);
     96            delete pe_not_e2;
     97
     98            return make_not(make_or(e1, e2));
     99        }
     100        else if (equal_exprs(pe_not_e1->getExpr(), expr2)) {
     101            delete expr1;
     102            delete expr2;
    95103            return new All(0); //Return false literal.
    96104        }
    97         else
    98         {
    99             return new And(expr1, expr2);
    100         }
    101     }
    102     else if (Not* pe_not_e2 = dynamic_cast<Not*>(expr2))
    103     {
    104         if (equal_exprs(expr1, pe_not_e2->getExpr()))
    105         {
     105    }
     106    else if (Not * pe_not_e2 = dynamic_cast<Not*>(expr2)) {
     107        if (equal_exprs(expr1, pe_not_e2->getExpr())) {
     108            delete expr1;
     109            delete expr2;
    106110            return new All(0);
    107111        }
    108         else
    109         {
    110             return new And(expr1, expr2);
    111         }
    112     }
    113     else
    114     {
    115         return new And(expr1, expr2);
    116     }
    117 }
    118 
    119 PabloE* CC_Compiler_Helper::make_or(PabloE *expr1, PabloE *expr2)
    120 {
    121     if (All* all = dynamic_cast<All*>(expr1))
    122     {
    123         if (all->getNum() == 1)
    124         {
    125             return new All(1); //Return a true literal.
    126         }
    127         else //if (all->getNum() == 0)
    128         {
     112    }
     113    return new And(expr1, expr2);
     114}
     115
     116PabloE* CC_Compiler_Helper::make_or(PabloE * expr1, PabloE * expr2)
     117{
     118    if (All * all = dynamic_cast<All*>(expr1)) {
     119        if (all->getNum() == 1) {
     120            delete expr2;
     121            return all; //Return a true literal.
     122        }
     123        else { //if (all->getNum() == 0)
     124            delete all;
    129125            return expr2;
    130126        }
    131127    }
    132     else if (All* all = dynamic_cast<All*>(expr2))
    133     {
    134         if (all->getNum() == 1)
    135         {
    136             return new All(1); //Return a true literal.
    137         }
    138         else //if (all->getNum() == 0)
    139         {
     128    else if (All * all = dynamic_cast<All*>(expr2)) {
     129        if (all->getNum() == 1) {
     130            delete expr1;
     131            return all; //Return a true literal.
     132        }
     133        else { //if (all->getNum() == 0)
     134            delete all;
    140135            return expr1;
    141136        }
    142137    }
    143     else if (Not* pe_not_e1 = dynamic_cast<Not*>(expr1))
    144     {
    145         return make_not(make_and(pe_not_e1->getExpr(), make_not(expr2)));
    146     }
    147     else if (Not* pe_not_e2 = dynamic_cast<Not*>(expr2))
    148     {
    149         return make_not(make_and(make_not(expr1), pe_not_e2->getExpr()));
    150     }
    151     else if (equal_exprs(expr1, expr2))
    152     {
     138    else if (Not* pe_not_e1 = dynamic_cast<Not*>(expr1)) {
     139        // ¬a||b = ¬¬(¬a||b) = ¬(a ∧ ¬b)
     140        PabloE * expr1 = pe_not_e1->getExpr();
     141        pe_not_e1->setExpr(nullptr);
     142        delete pe_not_e1;
     143        return make_not(make_and(expr1, make_not(expr2)));
     144    }
     145    else if (Not* pe_not_e2 = dynamic_cast<Not*>(expr2)) {
     146        PabloE * expr2 = pe_not_e1->getExpr();
     147        pe_not_e2->setExpr(nullptr);
     148        delete pe_not_e2;
     149        return make_not(make_and(expr2, make_not(expr1)));
     150    }
     151    else if (equal_exprs(expr1, expr2)) {
     152        delete expr2;
    153153        return expr1;
    154154    }
     
    158158        if (And* and_expr2 = dynamic_cast<And*>(expr2))
    159159        {
     160            PabloE * expr1a = and_expr1->getExpr1();
     161            PabloE * expr1b = and_expr1->getExpr2();
     162            PabloE * expr2a = and_expr2->getExpr1();
     163            PabloE * expr2b = and_expr2->getExpr1();
     164
    160165            //These optimizations factor out common components that can occur when sets are formed by union
    161166            //(e.g., union of [a-z] and [A-Z].
    162             if (equal_exprs(and_expr1->getExpr1(), and_expr2->getExpr1()))
    163             {
    164                 return make_and(and_expr1->getExpr1(), make_or(and_expr1->getExpr2(), and_expr2->getExpr2()));
    165             }
    166             else if (equal_exprs(and_expr1->getExpr2(), and_expr2->getExpr2()))
    167             {
    168                 return make_and(and_expr1->getExpr2(), make_or(and_expr1->getExpr1(), and_expr2->getExpr1()));
    169             }
    170             else if (equal_exprs(and_expr1->getExpr1(), and_expr2->getExpr2()))
    171             {
    172                 return make_and(and_expr1->getExpr1(), make_or(and_expr1->getExpr2(), and_expr2->getExpr1()));
    173             }
    174             else if (equal_exprs(and_expr1->getExpr2(), and_expr2->getExpr1()))
    175             {
    176                 return make_and(and_expr1->getExpr2(), make_or(and_expr1->getExpr1(), and_expr2->getExpr2()));
     167            if (equal_exprs(expr1a, expr2a))
     168            {
     169                return make_and(expr1a, make_or(expr1b, expr2b));
     170            }
     171            else if (equal_exprs(expr1b, expr2b))
     172            {
     173                return make_and(expr1b, make_or(expr1a, expr2a));
     174            }
     175            else if (equal_exprs(expr1a, expr2b))
     176            {
     177                return make_and(expr1a, make_or(expr1b, expr2a));
     178            }
     179            else if (equal_exprs(expr1b, expr2a))
     180            {
     181                return make_and(expr1b, make_or(expr1a, expr2b));
    177182            }
    178183        }
  • icGREP/icgrep-devel/icgrep/compiler_helper.cpp

    r3850 r4196  
    3535        }
    3636    }
    37     else if (Not* pe_not = dynamic_cast<Not*>(expr))
    38     {
    39         return pe_not->getExpr();
    40     }
    41     else
    42         return new Not(expr);
    43 
     37    else if (Not* pe_not = dynamic_cast<Not*>(expr)) {
     38        PabloE * expr = pe_not->getExpr();
     39        pe_not->setExpr(nullptr);
     40        delete pe_not;
     41        return expr;
     42    }
     43    return new Not(expr);
    4444}
    4545
  • icGREP/icgrep-devel/icgrep/pe_and.cpp

    r4187 r4196  
    1414}
    1515
    16 And::~And()
    17 {
     16And::~And() {
    1817    delete mExpr1;
    1918    delete mExpr2;
    2019}
    2120
    22 PabloE* And::getExpr1() const
    23 {
     21PabloE * And::getExpr1() const {
    2422    return mExpr1;
    2523}
    2624
    27 PabloE* And::getExpr2() const
    28 {
     25PabloE * And::getExpr2() const {
    2926    return mExpr2;
    3027}
  • icGREP/icgrep-devel/icgrep/pe_not.cpp

    r4187 r4196  
    88
    99Not::Not(PabloE* expr)
    10 {
     10: mExpr(expr) {
     11
     12}
     13
     14Not::~Not() {
     15    delete mExpr;
     16}
     17
     18PabloE* Not::getExpr() const {
     19    return mExpr;
     20}
     21
     22void Not::setExpr(PabloE * expr) {
    1123    mExpr = expr;
    1224}
    1325
    14 Not::~Not()
    15 {
    16     delete mExpr;
    17 }
    18 
    19 PabloE* Not::getExpr() const
    20 {
    21     return mExpr;
    22 }
    23 
    24 
  • icGREP/icgrep-devel/icgrep/pe_not.h

    r4187 r4196  
    1313{
    1414public:
    15     Not(PabloE* expr);
     15    Not(PabloE * expr);
    1616    ~Not();
    17     PabloE* getExpr() const;
     17    PabloE * getExpr() const;
     18    void setExpr(PabloE * expr = nullptr);
    1819private:
    1920    PabloE* mExpr;
Note: See TracChangeset for help on using the changeset viewer.