Changeset 4815


Ignore:
Timestamp:
Oct 3, 2015, 4:48:15 PM (2 years ago)
Author:
nmedfort
Message:

Bug fixes and removal of byte class compiler.

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

Legend:

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

    r4812 r4815  
    4747}
    4848
    49 void CC_Compiler::compileByteClasses(RE * re) {
    50     if (Alt * alt = dyn_cast<Alt>(re)) {
    51         for (auto i = alt->begin(); i != alt->end(); ++i) {
    52             compileByteClasses(*i);
    53         }
    54     }
    55     else if (Seq * seq = dyn_cast<Seq>(re)) {
    56         for (auto i = seq->begin(); i != seq->end(); ++i) {
    57             compileByteClasses(*i);
    58         }
    59     }
    60     else if (Rep * rep = dyn_cast<Rep>(re)) {
    61         compileByteClasses(rep->getRE());
    62     }
    63     else if (Assertion * a = dyn_cast<Assertion>(re)) {
    64         compileByteClasses(a->getAsserted());
    65     }
    66     else if (Diff * diff = dyn_cast<Diff>(re)) {
    67         compileByteClasses(diff->getRH());
    68         compileByteClasses(diff->getLH());
    69     }
    70     else if (Intersect * e = dyn_cast<Intersect>(re)) {
    71         compileByteClasses(e->getRH());
    72         compileByteClasses(e->getLH());
    73     }
    74     else if (Name * name = dyn_cast<Name>(re)) {
    75         RE * def = name->getDefinition();
    76         if (def) {
    77             if (!isa<CC>(def)) {
    78                 compileByteClasses(def);
    79             }
    80             else if (name->getCompiled() == nullptr) {
    81                 name->setCompiled(compileCC(cast<CC>(def)));
    82             }
    83         }
    84     }
    85     else if (isa<CC>(re)) {
    86         throw std::runtime_error("icgrep internal error: unexpected CC object \"" + Printer_RE::PrintRE(re) + "\" found in compileByteClasses.");
    87     }
    88 }
    89 
    9049template<typename PabloBlockOrBuilder>
    9150PabloAST * CC_Compiler::charset_expr(const CC * cc, PabloBlockOrBuilder & pb) {
  • icGREP/icgrep-devel/icgrep/cc/cc_compiler.h

    r4681 r4815  
    3838
    3939    pablo::Assign * compileCC(const std::string && canonicalName, const re::CC *cc, pablo::PabloBuilder & builder);
    40 
    41     void compileByteClasses(re::RE * re);
    4240
    4341    pablo::PabloBuilder & getBuilder();
  • icGREP/icgrep-devel/icgrep/re/re_compiler.cpp

    r4814 r4815  
    2929#include <iostream>
    3030#include <pablo/printer_pablos.h>
    31 #ifdef USE_BOOST
    32 #include <boost/container/flat_set.hpp>
    33 #else
    34 #include <unordered_set>
    35 #endif
    3631
    3732#include "llvm/Support/CommandLine.h"
     
    186181}
    187182
     183static inline CC * getDefinitionIfCC(RE * re) {
     184    if (LLVM_LIKELY(isa<Name>(re))) {
     185        Name * name = cast<Name>(re);
     186        if (name->getDefinition() && isa<CC>(name->getDefinition())) {
     187            return cast<CC>(name->getDefinition());
     188        }
     189    }
     190    return nullptr;
     191}
    188192
    189193RE * RE_Compiler::resolveUnicodeProperties(RE * re) {
     
    193197    using NameMap = UCD::UCDCompiler::NameMap;
    194198
    195     struct UnicodePropertyResolver {
    196 
    197         static inline CC * getNamedCC(RE * re) {
    198             if (LLVM_LIKELY(isa<Name>(re))) {
    199                 Name * name = cast<Name>(re);
    200                 if (name->getDefinition() && isa<CC>(name->getDefinition())) {
    201                     return cast<CC>(name->getDefinition());
     199    PropertyMap                 propertyMap;
     200    NamespacedPropertyMap       namespacedPropertyMap;
     201    NameMap                     nameMap;
     202
     203    std::function<RE*(RE*)> resolve = [&](RE * re) -> RE * {
     204        if (Name * name = dyn_cast<Name>(re)) {
     205            if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
     206                name->setDefinition(resolve(name->getDefinition()));
     207            } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty)) {
     208                // Attempt to look up an equivalently named Name object
     209                if (name->hasNamespace()) {
     210                    const auto f = namespacedPropertyMap.find(std::make_pair(name->getNamespace(), name->getName()));
     211                    if (f != namespacedPropertyMap.end()) {
     212                        if (f->second != name) {
     213                            return f->second;
     214                        }
     215                    }
     216                    namespacedPropertyMap.insert(std::make_pair(std::make_pair(name->getNamespace(), name->getName()), name));
     217                } else {
     218                    const auto f = propertyMap.find(name->getName());
     219                    if (f != propertyMap.end()) {
     220                        if (f->second != name) {
     221                            return f->second;
     222                        }
     223                    }
     224                    propertyMap.insert(std::make_pair(name->getName(), name));
    202225                }
    203             }
    204             return nullptr;
    205         }
    206 
    207         RE * resolve(RE * re) {
    208             if (Name * name = dyn_cast<Name>(re)) {
    209                 if (LLVM_LIKELY(name->getDefinition() != nullptr)) {
    210                     name->setDefinition(resolve(name->getDefinition()));
    211                 } else if (LLVM_LIKELY(name->getType() == Name::Type::UnicodeProperty)) {
    212                     // Attempt to look up an equivalently named Name object
    213                     if (name->hasNamespace()) {
    214                         const auto f = mNamespacedPropertyMap.find(std::make_pair(name->getNamespace(), name->getName()));
    215                         if (f != mNamespacedPropertyMap.end()) {
    216                             if (f->second != name) {
    217                                 return f->second;
    218                             }
    219                         }
    220                         mNamespacedPropertyMap.insert(std::make_pair(std::make_pair(name->getNamespace(), name->getName()), name));
     226                if (UCD::resolvePropertyDefinition(name)) {
     227                    resolve(name->getDefinition());
     228                } else {
     229                    #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
     230                    if (UsePregeneratedUnicode) {
     231                        const std::string functionName = UCD::resolvePropertyFunction(name);
     232                        const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
     233                        Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
     234                        name->setCompiled(mPB.createAnd(call, mNonLineBreak));
    221235                    } else {
    222                         const auto f = mPropertyMap.find(name->getName());
    223                         if (f != mPropertyMap.end()) {
    224                             if (f->second != name) {
    225                                 return f->second;
    226                             }
    227                         }
    228                         mPropertyMap.insert(std::make_pair(name->getName(), name));
     236                    #endif
     237                        name->setDefinition(makeCC(std::move(UCD::resolveUnicodeSet(name))));
     238                    #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    229239                    }
    230                     if (UCD::resolvePropertyDefinition(name)) {
    231                         resolve(name->getDefinition());
    232                     } else {
    233                         #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    234                         if (UsePregeneratedUnicode) {
    235                             const std::string functionName = UCD::resolvePropertyFunction(name);
    236                             const UCD::ExternalProperty & ep = UCD::resolveExternalProperty(functionName);
    237                             Call * call = mPB.createCall(Prototype::Create(functionName, std::get<1>(ep), std::get<2>(ep), std::get<0>(ep)), mCCCompiler.getBasisBits());
    238                             name->setCompiled(mPB.createAnd(call, mNonLineBreak));
    239                         } else {
    240                         #endif
    241                             name->setDefinition(makeCC(std::move(UCD::resolveUnicodeSet(name))));
    242                         #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    243                         }
    244                         #endif
    245                     }
     240                    #endif
     241                }
     242            } else {
     243                throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
     244            }
     245        } else if (Seq * seq = dyn_cast<Seq>(re)) {
     246            for (auto si = seq->begin(); si != seq->end(); ) {
     247                RE * re = resolve(*si);
     248                if (LLVM_UNLIKELY(isa<Seq>(re))) {
     249                    auto sj = cast<Seq>(re)->begin();
     250                    *si = *sj;
     251                    si = seq->insert(++si, ++sj, cast<Seq>(re)->end());
    246252                } else {
    247                     throw std::runtime_error("All non-unicode-property Name objects should have been defined prior to Unicode property resolution.");
     253                    *si++ = re;
    248254                }
    249             } else if (Seq * seq = dyn_cast<Seq>(re)) {
    250                 for (auto si = seq->begin(); si != seq->end(); ) {
    251                     RE * re = resolve(*si);
    252                     if (LLVM_UNLIKELY(isa<Seq>(re))) {
    253                         auto sj = cast<Seq>(re)->begin();
    254                         *si = *sj;
    255                         si = seq->insert(++si, ++sj, cast<Seq>(re)->end());
    256                     } else {
    257                         *si++ = re;
    258                     }
     255            }
     256        } else if (Alt * alt = dyn_cast<Alt>(re)) {
     257            CC * unionCC = nullptr;
     258            for (auto ai = alt->begin(); ai != alt->end(); ) {
     259                RE * re = resolve(*ai);
     260                if (CC * cc = getDefinitionIfCC(re)) {
     261                    unionCC = (unionCC == nullptr) ? cc : makeCC(unionCC, cc);
     262                    ai = alt->erase(ai);
     263                } else if (LLVM_UNLIKELY(isa<Alt>(re))) {
     264                    auto aj = cast<Alt>(re)->begin();
     265                    *ai = *aj;
     266                    ai = alt->insert(++ai, ++aj, cast<Alt>(re)->end());
     267                } else {
     268                    *ai++ = re;
    259269                }
    260             } else if (Alt * alt = dyn_cast<Alt>(re)) {
    261                 CC * unionCC = nullptr;
    262                 for (auto ai = alt->begin(); ai != alt->end(); ) {
    263                     RE * re = resolve(*ai);
    264                     if (CC * cc = getNamedCC(re)) {
    265                         unionCC = (unionCC == nullptr) ? cc : makeCC(unionCC, cc);
    266                         ai = alt->erase(ai);
    267                     } else if (LLVM_UNLIKELY(isa<Alt>(re))) {
    268                         auto aj = cast<Alt>(re)->begin();
    269                         *ai = *aj;
    270                         ai = alt->insert(++ai, ++aj, cast<Alt>(re)->end());
    271                     } else {
    272                         *ai++ = re;
    273                     }
    274                 }
    275                 if (unionCC) {
    276                     alt->push_back(makeName("union", unionCC));
    277                 }
    278                 if (alt->size() == 1) {
    279                     return alt->front();
    280                 }
    281             } else if (Rep * rep = dyn_cast<Rep>(re)) {
    282                 rep->setRE(resolve(rep->getRE()));
    283             } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    284                 a->setAsserted(resolve(a->getAsserted()));
    285             } else if (Diff * diff = dyn_cast<Diff>(re)) {
    286                 diff->setLH(resolve(diff->getLH()));
    287                 diff->setRH(resolve(diff->getRH()));
    288                 #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    289                 if (!UsePregeneratedUnicode) {
    290                 #endif
    291                     CC * lh = getNamedCC(diff->getLH());
    292                     CC * rh = getNamedCC(diff->getRH());
    293                     if (lh && rh) {
    294                         return resolve(makeName("diff", subtractCC(lh, rh)));
    295                     }
    296                 #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    297                 }
    298                 #endif
    299             } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
    300                 ix->setLH(resolve(ix->getLH()));
    301                 ix->setRH(resolve(ix->getRH()));
    302                 #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    303                 if (!UsePregeneratedUnicode) {
    304                 #endif
    305                     CC * lh = getNamedCC(diff->getLH());
    306                     CC * rh = getNamedCC(diff->getRH());
    307                     if (lh && rh) {
    308                         return resolve(makeName("intersect", intersectCC(lh, rh)));
    309                     }
    310                 #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    311                 }
    312                 #endif
    313             }
    314             return re;
    315         }
    316 
    317         static void collect(RE * re, NameMap & nameMap) {
    318             if (Name * name = dyn_cast<Name>(re)) {
     270            }
     271            if (unionCC) {
     272                alt->push_back(makeName("union", unionCC));
     273            }
     274            if (alt->size() == 1) {
     275                return alt->front();
     276            }
     277        } else if (Rep * rep = dyn_cast<Rep>(re)) {
     278            rep->setRE(resolve(rep->getRE()));
     279        } else if (Assertion * a = dyn_cast<Assertion>(re)) {
     280            a->setAsserted(resolve(a->getAsserted()));
     281        } else if (Diff * diff = dyn_cast<Diff>(re)) {
     282            diff->setLH(resolve(diff->getLH()));
     283            diff->setRH(resolve(diff->getRH()));
     284            CC * lh = getDefinitionIfCC(diff->getLH());
     285            CC * rh = getDefinitionIfCC(diff->getRH());
     286            if (lh && rh) {
     287                return resolve(makeName("diff", subtractCC(lh, rh)));
     288            }
     289        } else if (Intersect * ix = dyn_cast<Intersect>(re)) {
     290            ix->setLH(resolve(ix->getLH()));
     291            ix->setRH(resolve(ix->getRH()));
     292            CC * lh = getDefinitionIfCC(diff->getLH());
     293            CC * rh = getDefinitionIfCC(diff->getRH());
     294            if (lh && rh) {
     295                return resolve(makeName("intersect", intersectCC(lh, rh)));
     296            }
     297        }
     298        return re;
     299    };
     300
     301    std::function<void(RE*)> gather = [&](RE * re) {
     302        if (Name * name = dyn_cast<Name>(re)) {
     303            if (name->getCompiled() == nullptr) {
    319304                if (isa<CC>(name->getDefinition())) {
    320305                    nameMap.emplace(name, nullptr);
    321306                } else {
    322                     collect(name->getDefinition(), nameMap);
     307                    gather(name->getDefinition());
    323308                }
    324             } else if (Seq * seq = dyn_cast<Seq>(re)) {
    325                 for (auto re : *seq) {
    326                     collect(re, nameMap);
    327                 }
    328             } else if (Alt * alt = dyn_cast<Alt>(re)) {
    329                 for (auto re : *alt) {
    330                     collect(re, nameMap);
    331                 }
    332             } else if (Rep * rep = dyn_cast<Rep>(re)) {
    333                 collect(rep->getRE(), nameMap);
    334             } else if (Assertion * a = dyn_cast<Assertion>(re)) {
    335                 collect(a->getAsserted(), nameMap);
    336             } else if (Diff * diff = dyn_cast<Diff>(re)) {
    337                 collect(diff->getLH(), nameMap);
    338                 collect(diff->getRH(), nameMap);
    339             }
    340         }
    341 
    342     private:
    343         PropertyMap                 mPropertyMap;
    344         NamespacedPropertyMap       mNamespacedPropertyMap;
     309            }
     310        } else if (Seq * seq = dyn_cast<Seq>(re)) {
     311            for (auto re : *seq) {
     312                gather(re);
     313            }
     314        } else if (Alt * alt = dyn_cast<Alt>(re)) {
     315            for (auto re : *alt) {
     316                gather(re);
     317            }
     318        } else if (Rep * rep = dyn_cast<Rep>(re)) {
     319            gather(rep->getRE());
     320        } else if (Assertion * a = dyn_cast<Assertion>(re)) {
     321            gather(a->getAsserted());
     322        } else if (Diff * diff = dyn_cast<Diff>(re)) {
     323            gather(diff->getLH());
     324            gather(diff->getRH());
     325        }
    345326    };
    346327
    347     UnicodePropertyResolver resolver;
    348     re = resolver.resolve(re);
    349     #ifndef DISABLE_PREGENERATED_UCD_FUNCTIONS
    350     if (UsePregeneratedUnicode) return re;
    351     #endif
    352     NameMap nameMap;
    353     resolver.collect(re, nameMap);
     328    re = resolve(re);
     329    gather(re);
    354330
    355331    if (nameMap.size() > 0) {
  • icGREP/icgrep-devel/icgrep/toolchain.cpp

    r4814 r4815  
    119119}
    120120   
    121 pablo::PabloFunction * re2pablo_compiler(const Encoding encoding, re::RE * re_ast) {
    122    
    123     pablo::PabloFunction * function = pablo::PabloFunction::Create("process_block", 8, 2);
    124    
     121pablo::PabloFunction * re2pablo_compiler(const Encoding encoding, re::RE * re_ast) {   
     122    pablo::PabloFunction * function = pablo::PabloFunction::Create("process_block", 8, 2);   
    125123    cc::CC_Compiler cc_compiler(*function, encoding);
    126    
    127     cc_compiler.compileByteClasses(re_ast);
    128    
    129     if (PrintCompiledCCcode) {
    130         //Print to the terminal the AST that was generated by the character class compiler.
    131         llvm::raw_os_ostream cerr(std::cerr);
    132         cerr << "CC AST:" << "\n";
    133         PabloPrinter::print(function->getEntryBlock().statements(), cerr);
    134     }
    135 
    136124    re::RE_Compiler re_compiler(*function, cc_compiler);
    137125    re_compiler.initializeRequiredStreams();
Note: See TracChangeset for help on using the changeset viewer.