Changeset 4247


Ignore:
Timestamp:
Oct 18, 2014, 4:05:41 PM (4 years ago)
Author:
cameron
Message:

All -> Zeroes, Ones

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

Legend:

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

    r4246 r4247  
    5353#find_package(Boost 1.21 COMPONENTS system)
    5454
    55 add_library(PabloADT pablo/pe_advance.cpp pablo/pe_all.cpp pablo/pe_and.cpp pablo/pe_call.cpp pablo/pe_charclass.cpp  pablo/pe_matchstar.cpp pablo/pe_scanthru.cpp pablo/pe_not.cpp  pablo/pe_or.cpp  pablo/pabloAST.cpp  pablo/pe_sel.cpp  pablo/pe_var.cpp  pablo/pe_xor.cpp pablo/ps_assign.cpp  pablo/ps_if.cpp  pablo/codegenstate.cpp  pablo/symbol_generator.cpp pablo/ps_while.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp)
     55add_library(PabloADT pablo/pe_advance.cpp pablo/pe_and.cpp pablo/pe_call.cpp pablo/pe_charclass.cpp  pablo/pe_matchstar.cpp pablo/pe_scanthru.cpp pablo/pe_not.cpp  pablo/pe_or.cpp  pablo/pabloAST.cpp  pablo/pe_sel.cpp  pablo/pe_var.cpp  pablo/pe_xor.cpp pablo/ps_assign.cpp  pablo/ps_if.cpp  pablo/codegenstate.cpp  pablo/symbol_generator.cpp pablo/ps_while.cpp pablo/printer_pablos.cpp pablo/pablo_compiler.cpp)
    5656add_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 re/re_reducer.cpp re/re_nullable.cpp re/re_simplifier.cpp re/re_compiler.cpp re/printer_re.cpp)
    5757add_library(CCADT cc/cc_namemap.cpp cc/cc_compiler.cpp utf_encoding.cpp utf8_encoder.cpp unicode_categories.h)
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.cpp

    r4244 r4247  
    7272inline PabloAST * CC_Compiler::charset_expr(const CC * cc) {
    7373    if (cc->empty()) {
    74         return mCG.createAll(0);
     74        return mCG.createZeroes();
    7575    }
    7676    if (cc->size() > 2) {
     
    118118{
    119119    if (selected_bits == 0) {
    120         return mCG.createAll(1);
     120        return mCG.createOnes();
    121121    }
    122122
     
    140140        else
    141141        {
    142             bit_terms.push_back(mCG.createAll(1));
     142            bit_terms.push_back(mCG.createOnes());
    143143        }
    144144        selected_bits &= ~test_bit;
     
    196196    if (N == 0)
    197197    {
    198         return mCG.createAll(1); //Return a true literal.
     198        return mCG.createOnes(); //Return a true literal.
    199199    }
    200200    else if (((N % 2) == 0) && ((n >> (N - 2)) == 0))
     
    239239    */
    240240    if ((n + 1) == (1 << N)) {
    241         return mCG.createAll(1); //True.
     241        return mCG.createOnes(); //True.
    242242    }
    243243    else {
  • icGREP/icgrep-devel/icgrep/include/simd-lib/pabloSupport.hpp

    r4037 r4247  
    123123        u.bitblock = v;   
    124124    int pos;
    125     ScanWord s, t, bit;
     125    ScanWord s;
    126126    for (unsigned int i = 0; i < sizeof(BitBlock)/sizeof(ScanWord); i++) {
    127127        s = u.elems[i];
    128128        if (s != 0) {
    129129            int bitpos = scan_forward_zeroes(s);
    130             int pos = block_base + (i * sizeof(ScanWord) * 8) + bitpos;
     130            pos = block_base + (i * sizeof(ScanWord) * 8) + bitpos;
    131131        }
    132132    }
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4244 r4247  
    1111#include <pablo/pe_string.h>
    1212#include <pablo/pe_advance.h>
    13 #include <pablo/pe_all.h>
    1413#include <pablo/pe_and.h>
    1514#include <pablo/pe_call.h>
     
    2625#include <pablo/ps_if.h>
    2726#include <pablo/ps_while.h>
     27#include <pablo/pe_zeroes.h>
     28#include <pablo/pe_ones.h>
    2829#include <pablo/symbol_generator.h>
    2930#include <map>
     
    4041    PabloBlock(SymbolGenerator & symgen)
    4142    : mSymbolGenerator(symgen)
    42     , mAll{{new All(0), new All(1)}}
     43    , mZeroes(new Zeroes())
     44    , mOnes(new Ones())
    4345    , mUnary(nullptr, this)
    4446    , mBinary(nullptr, this)
     
    5052    PabloBlock(PabloBlock & cg)
    5153    : mSymbolGenerator(cg.mSymbolGenerator)
    52     , mAll(cg.mAll) // inherit the original "All" variables for simplicity
     54    , mZeroes(cg.mZeroes) // inherit the original "All" variables for simplicity
     55    , mOnes(cg.mOnes) // inherit the original "All" variables for simplicity
    5356    , mUnary(&(cg.mUnary), this)
    5457    , mBinary(&(cg.mBinary), this)
     
    6063    Advance * createAdvance(PabloAST * expr);
    6164
    62     inline All * createAll(const bool value) const {
    63         return mAll[value];
     65    inline Zeroes * createZeroes() const {
     66        return mZeroes;
     67    }
     68
     69    inline Ones * createOnes() const {
     70        return mOnes;
    6471    }
    6572
     
    180187private:   
    181188    SymbolGenerator &                               mSymbolGenerator;
    182     const std::array<All *, 2>                      mAll;
     189    Zeroes *                                        mZeroes;
     190    Ones *                                  mOnes;
    183191    ExpressionMap<PabloAST *>                         mUnary;
    184192    ExpressionMap<PabloAST *, PabloAST *>               mBinary;
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.cpp

    r4244 r4247  
    77#include "pabloAST.h"
    88#include "pe_advance.h"
    9 #include "pe_all.h"
    109#include "pe_and.h"
    1110#include "pe_call.h"
     
    1918#include "pe_var.h"
    2019#include "pe_xor.h"
     20#include "pe_zeroes.h"
     21#include "pe_ones.h"
    2122
    2223namespace pablo {
     
    3233bool equals(const PabloAST * expr1, const PabloAST * expr2) {
    3334    if (expr1->getClassTypeId() == expr2->getClassTypeId()) {
    34         if (const All * all1 = dyn_cast<const All>(expr1)) {
    35             if (const All * all2 = cast<const All>(expr2)) {
    36                 return all1->getValue() == all2->getValue();
    37             }
     35        if ((isa<const Zeroes>(expr1)) || (isa<const Ones>(expr1))) {
     36            return true;
    3837        }
    3938        else if (const Var * var1 = dyn_cast<const Var>(expr1)) {
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4244 r4247  
    2020    enum class ClassTypeId : unsigned {
    2121        Advance
    22         , All
    2322        , And
    2423        , Call
     
    3534        , While
    3635        , String
     36        , Zeroes
     37        , Ones
    3738    };
    3839    inline ClassTypeId getClassTypeId() const {
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r4244 r4247  
    628628    Value * retVal = nullptr;
    629629    IRBuilder<> b(mBasicBlock);
    630     if (const All* all = dyn_cast<All>(expr))
     630    if (isa<Ones>(expr))
    631631    {
    632632        Value* ptr_all = b.CreateAlloca(mXi64Vect);
    633         b.CreateStore((all->getValue() == 0 ? mZeroInitializer : mAllOneInitializer), ptr_all);
     633        b.CreateStore(mAllOneInitializer, ptr_all);
     634        retVal = b.CreateLoad(ptr_all);
     635    }
     636    else if (isa<Zeroes>(expr))
     637    {
     638        Value* ptr_all = b.CreateAlloca(mXi64Vect);
     639        b.CreateStore(mZeroInitializer, ptr_all);
    634640        retVal = b.CreateLoad(ptr_all);
    635641    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_and.cpp

    r4244 r4247  
    1111
    1212PabloAST * OptimizeAnd::operator ()(PabloAST * expr1, PabloAST * expr2) {
    13     if (All * all = dyn_cast<All>(expr1)) {
    14         if (all->getValue()) {
    15             return expr2;
    16         }
    17         else {
    18             return cg.createAll(0);
    19         }
     13    if (isa<Ones>(expr1)) {
     14        return expr2;
    2015    }
    21     else if (All* all = dyn_cast<All>(expr2)) {
    22         if (all->getValue()) {
    23             return expr1;
    24         }
    25         else {
    26             return cg.createAll(0);
    27         }
     16    else if (isa<Zeroes>(expr1)){
     17        return expr1;       
     18    }
     19    else if (isa<Ones>(expr2)) {
     20        return expr1;
     21    }
     22    else if (isa<Zeroes>(expr2)){
     23        return expr2;
    2824    }
    2925    else if (equals(expr1, expr2)) {
     
    3531        }
    3632        else if (equals(pe_not_e1->getExpr(), expr2)) {
    37             return cg.createAll(0);
     33            return cg.createZeroes();
    3834        }
    3935    }
    4036    else if (Not * pe_not_e2 = dyn_cast<Not>(expr2)) {
    4137        if (equals(expr1, pe_not_e2->getExpr())) {
    42             return cg.createAll(0);
     38            return cg.createZeroes();
    4339        }
    4440    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_not.cpp

    r4244 r4247  
    1212
    1313PabloAST * OptimizeNot::operator ()(PabloAST * expr) {
    14     if (All * all = dyn_cast<All>(expr)) {
    15         return cg.createAll(!all->getValue());
     14    if (isa<Ones>(expr)) {
     15        return cg.createZeroes();
     16    }
     17    else if (isa<Zeroes>(expr)){
     18        return cg.createOnes();       
    1619    }
    1720    else if (Not * pe_not = dyn_cast<Not>(expr)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_or.cpp

    r4244 r4247  
    1111
    1212PabloAST * OptimizeOr::operator ()(PabloAST * expr1, PabloAST * expr2) {
    13 
    14     if (All * all = dyn_cast<All>(expr1)) {
    15         if (all->getValue() == 1) {
    16             return all; //Return a true literal.
    17         }
    18         else {
    19             return expr2;
    20         }
     13    if (isa<Ones>(expr1)) {
     14        return expr1;
    2115    }
    22     else if (All * all = dyn_cast<All>(expr2)) {
    23         if (all->getValue() == 1) {
    24             return all; //Return a true literal.
    25         }
    26         else {
    27             return expr1;
    28         }
     16    else if (isa<Zeroes>(expr1)){
     17        return expr2;       
     18    }
     19    else if (isa<Ones>(expr2)) {
     20        return expr2;
     21    }
     22    else if (isa<Zeroes>(expr2)){
     23        return expr1;
     24    }
     25    else if (equals(expr1, expr2)) {
     26        return expr1;
    2927    }
    3028    else if (Not * not1 = dyn_cast<Not>(expr1)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_sel.cpp

    r4244 r4247  
    1111
    1212PabloAST * OptimizeSel::operator()(PabloAST * if_expr, PabloAST * t_expr, PabloAST * f_expr) {
    13     if (All * all_if_expr = dyn_cast<All>(if_expr)) {
    14         if (all_if_expr->getValue()) {
    15             return t_expr;
    16         }
    17         else {
    18             return f_expr;
    19         }
     13    if (isa<Ones>(if_expr)) {
     14        return t_expr;
    2015    }
    21     else if (All * all_t_expr = dyn_cast<All>(t_expr)) {
    22         if (all_t_expr->getValue()) {
    23             return cg.createOr(if_expr, f_expr);
    24         }
    25         else {
    26             return cg.createAnd(cg.createNot(if_expr), f_expr);
    27         }
     16    else if (isa<Zeroes>(if_expr)){
     17        return f_expr;       
    2818    }
    29     else if (All * all_f_expr = dyn_cast<All>(f_expr)) {
    30         if (all_f_expr->getValue()) {
    31             return cg.createOr(cg.createNot(if_expr), t_expr);
    32         }
    33         else {
    34             return cg.createAnd(if_expr, t_expr);
    35         }
     19    else if (isa<Ones>(t_expr)) {
     20        return cg.createOr(if_expr, f_expr);
     21    }
     22    else if (isa<Zeroes>(t_expr)){
     23        return cg.createAnd(cg.createNot(if_expr), f_expr);   
     24    }
     25    else if (isa<Ones>(f_expr)) {
     26        return cg.createOr(cg.createNot(if_expr), t_expr);
     27    }
     28    else if (isa<Zeroes>(f_expr)){
     29        return cg.createAnd(if_expr, t_expr);       
    3630    }
    3731    else if (equals(t_expr, f_expr)) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_xor.cpp

    r4244 r4247  
    1111
    1212PabloAST * OptimizeXor::operator()(PabloAST * expr1, PabloAST * expr2) {
    13     if (All * all1 = dyn_cast<All>(expr1)) {
    14         if (all1->getValue()) {
    15             return cg.createNot(expr2);
    16         }
    17         else {
    18             return expr2;
    19         }
     13    if (isa<Ones>(expr1)) {
     14        return cg.createNot(expr2);
    2015    }
    21     else if (All* all2 = dyn_cast<All>(expr2)) {
    22         if (all2->getValue() == 1) {
    23             return cg.createNot(expr1);
    24         }
    25         else { //if (all_expr2->getNum() == 0)
    26             return expr1;
    27         }
     16    else if (isa<Zeroes>(expr1)){
     17        return expr2;       
     18    }
     19    else if (isa<Ones>(expr2)) {
     20        return cg.createNot(expr1);
     21    }
     22    else if (isa<Zeroes>(expr2)){
     23        return expr1;
    2824    }
    2925    else if (Not * not1 = dyn_cast<Not>(expr1)) {
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r4244 r4247  
    1919#include <pablo/pabloAST.h>
    2020#include <pablo/pe_advance.h>
    21 #include <pablo/pe_all.h>
    2221#include <pablo/pe_and.h>
    2322#include <pablo/pe_call.h>
     
    3332#include <pablo/ps_if.h>
    3433#include <pablo/ps_while.h>
     34#include <pablo/pe_zeroes.h>
     35#include <pablo/pe_ones.h>
    3536#include <pablo/codegenstate.h>
    3637
     
    9293    std::string retVal = "";
    9394
    94     if (const All * all = dyn_cast<const All>(expr))
     95    if (isa<const Zeroes>(expr))
    9596    {
    96         retVal = "All " + std::to_string(all->getValue()) + " ";
     97        retVal = "Zeroes";
     98    }
     99    else if (isa<const Ones>(expr))
     100    {
     101        retVal = "Ones";
    97102    }
    98103    else if (const Call * pablo_call = dyn_cast<const Call>(expr))
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4246 r4247  
    2020#include <pablo/codegenstate.h>
    2121#include <pablo/pe_advance.h>
    22 #include <pablo/pe_all.h>
     22#include <pablo/pe_zeroes.h>
     23#include <pablo/pe_ones.h>
    2324#include <pablo/pe_and.h>
    2425#include <pablo/pe_call.h>
     
    7273        mInitial = cg.createVar(cg.createAssign(initial, cg.createOr(u8pfx, u8single)));
    7374        #ifdef USE_IF_FOR_NONFINAL
    74         mNonFinal = cg.createVar(cg.createAssign(gs_nonfinal, cg.createAll(0)));
     75        mNonFinal = cg.createVar(cg.createAssign(gs_nonfinal, cg.createZeroes()));
    7576        #endif
    7677        PabloAST * u8scope32 = cg.createAdvance(u8pfx3);
     
    8687    }
    8788    else {
    88         mInitial = cg.createAll(0);
    89         mNonFinal = cg.createAll(0);
    90     }
    91 
    92     Assign * start_marker = cg.createAssign("start", cg.createAll(1));
     89        mInitial = cg.createZeroes();
     90        mNonFinal = cg.createZeroes();
     91    }
     92
     93    Assign * start_marker = cg.createAssign("start", cg.createOnes());
    9394    PabloAST * result = process(re, start_marker, cg);
    9495
     
    160161inline Assign * RE_Compiler::process(Alt * alt, Assign * target, PabloBlock & cg) {
    161162    if (alt->empty()) {
    162         target = cg.createAssign(cg.ssa("fail"), cg.createAll(0)); // always fail (note: I'm not sure this ever occurs. How do I create a 0-element alternation?)
     163        target = cg.createAssign(cg.ssa("fail"), cg.createZeroes()); // always fail (note: I'm not sure this ever occurs. How do I create a 0-element alternation?)
    163164    }
    164165    else {
Note: See TracChangeset for help on using the changeset viewer.