Ignore:
Timestamp:
Nov 18, 2016, 1:46:55 PM (3 years ago)
Author:
nmedfort
Message:

Merged PabloFunction? and PabloKernel? classes. Updated projects where necessary.

Location:
icGREP/icgrep-devel/icgrep/pablo
Files:
2 added
6 deleted
36 edited
2 moved

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/analysis/pabloverifier.cpp

    r5202 r5217  
    11#include "pabloverifier.hpp"
    2 #include <pablo/function.h>
     2#include <pablo/pablo_kernel.h>
    33#include <pablo/codegenstate.h>
    44#include <pablo/printer_pablos.h>
     
    2727            continue;
    2828        }
    29         if (LLVM_UNLIKELY(isa<PabloFunction>(use))) {
    30             const PabloFunction * f = cast<PabloFunction>(use);
    31             bool isParameter = false;
    32             bool isResult = false;
    33             for (unsigned i = 0; i != f->getNumOfParameters(); ++i) {
    34                 if (f->getParameter(i) == expr) {
    35                     isParameter = true;
    36                     break;
    37                 }
    38             }
    39             for (unsigned i = 0; i != f->getNumOfResults(); ++i) {
    40                 if (f->getResult(i) == expr) {
    41                     isResult = true;
    42                     break;
    43                 }
    44             }
    45             if (LLVM_UNLIKELY(!(isParameter ^ isResult))) {
    46                 std::string tmp;
    47                 raw_string_ostream str(tmp);
    48                 str << "use-def error: ";
    49                 PabloPrinter::print(expr, str);
    50                 if (isParameter && isResult) {
    51                     str << " is both a parameter and result of ";
    52                 } else {
    53                     str << " is neither a parameter nor result of ";
    54                 }
    55                 PabloPrinter::print(f, str);
    56                 throw std::runtime_error(str.str());
    57             }
    58             ++uses;
    59         } else if (const Statement * const user = dyn_cast<Statement>(use)) {
     29        if (const Statement * const user = dyn_cast<Statement>(use)) {
    6030            // test whether this user is in a block in the program
    6131            if (LLVM_UNLIKELY(user->getParent() == nullptr || validScopes.count(user->getParent()) == 0)) {
     
    10171            }
    10272        } else if (isa<Var>(use)) {
    103             if (LLVM_UNLIKELY(isa<Branch>(expr) || isa<PabloFunction>(expr))) {
     73            if (LLVM_UNLIKELY(isa<Branch>(expr))) {
    10474                ++uses;
    10575            } else {
     
    169139}
    170140
    171 void verifyUseDefInformation(const PabloFunction & function) {
     141void verifyUseDefInformation(const PabloKernel * kernel) {
    172142    ScopeSet validScopes;
    173     gatherValidScopes(function.getEntryBlock(), validScopes);
    174     for (unsigned i = 0; i < function.getNumOfParameters(); ++i) {
    175         if (LLVM_UNLIKELY(function.getParameter(i) == nullptr)) {
    176             throw std::runtime_error("parameter " + std::to_string(i) + " is Null!");
    177         }
    178         testUsers(function.getParameter(i), validScopes);
    179     }
    180     for (unsigned i = 0; i < function.getNumOfResults(); ++i) {
    181         if (LLVM_UNLIKELY(function.getResult(i) == nullptr)) {
    182             throw std::runtime_error("result " + std::to_string(i) + " is Null!");
    183         }
    184         testUsers(function.getResult(i), validScopes);
    185     }
    186     verifyUseDefInformation(function.getEntryBlock(), validScopes);
     143    gatherValidScopes(kernel->getEntryBlock(), validScopes);
     144    for (unsigned i = 0; i < kernel->getNumOfInputs(); ++i) {
     145        testUsers(kernel->getInput(i), validScopes);
     146    }
     147    for (unsigned i = 0; i < kernel->getNumOfOutputs(); ++i) {
     148        testUsers(kernel->getOutput(i), validScopes);
     149    }
     150    verifyUseDefInformation(kernel->getEntryBlock(), validScopes);
    187151}
    188152
     
    326290}
    327291
    328 inline void verifyProgramStructure(const PabloFunction & function) {
     292inline void verifyProgramStructure(const PabloKernel * kernel) {
    329293    unsigned nestingDepth = 0;
    330     verifyProgramStructure(function.getEntryBlock(), nestingDepth);
     294    verifyProgramStructure(kernel->getEntryBlock(), nestingDepth);
    331295    if (LLVM_UNLIKELY(nestingDepth != 0)) {
    332296        // This error isn't actually possible to occur with the current AST structure but that could change
     
    401365}
    402366
    403 void isTopologicallyOrdered(const PabloFunction & function) {
     367void isTopologicallyOrdered(const PabloKernel * kernel) {
    404368    OrderingVerifier ov;
    405     for (unsigned i = 0; i != function.getNumOfParameters(); ++i) {
    406         ov.insert(function.getParameter(i));
    407     }
    408     for (unsigned i = 0; i != function.getNumOfResults(); ++i) {
    409         ov.insert(function.getResult(i));
    410     }
    411     isTopologicallyOrdered(function.getEntryBlock(), ov);
    412 }
    413 
    414 void PabloVerifier::verify(const PabloFunction & function, const std::string location) {
     369    for (unsigned i = 0; i != kernel->getNumOfInputs(); ++i) {
     370        ov.insert(kernel->getInput(i));
     371    }
     372    for (unsigned i = 0; i != kernel->getNumOfOutputs(); ++i) {
     373        ov.insert(kernel->getOutput(i));
     374    }
     375    isTopologicallyOrdered(kernel->getEntryBlock(), ov);
     376}
     377
     378void PabloVerifier::verify(const PabloKernel * kernel, const std::string & location) {
    415379    try {
    416         verifyProgramStructure(function);
    417         verifyUseDefInformation(function);
    418         isTopologicallyOrdered(function);
     380        verifyProgramStructure(kernel);
     381        verifyUseDefInformation(kernel);
     382        isTopologicallyOrdered(kernel);
    419383    } catch(std::runtime_error & err) {
    420384        raw_os_ostream out(std::cerr);
    421         PabloPrinter::print(function, out);
     385        PabloPrinter::print(kernel, out);
    422386        out.flush();
    423387        if (location.empty()) {
  • icGREP/icgrep-devel/icgrep/pablo/analysis/pabloverifier.hpp

    r4797 r5217  
    66namespace pablo {
    77
    8 class PabloFunction;
     8class PabloKernel;
    99
    1010class PabloVerifier {
    1111public:
    12     static void verify(const PabloFunction & function, const std::string location = "");
     12    static void verify(const PabloKernel * kernel, const std::string & location = "");
    1313};
    1414
  • icGREP/icgrep-devel/icgrep/pablo/branch.cpp

    r5202 r5217  
    1818    bool outside = false;
    1919    for (const PabloAST * user : var->users()) {
    20         if (isa<Assign>(user)) {
    21             // is this var assigned a value within the scope of the branch?
     20        if (isa<Assign>(user)) {           
     21
    2222            const PabloBlock * const scope = cast<Assign>(user)->getParent();
    2323
     24            // Is this Var assigned a value within the body of this branch?
    2425            for (const PabloBlock * test = scope; test; test = test->getPredecessor()) {
    2526                if (test == br->getBody()) {
     
    2829                    }
    2930                    inside = true;
    30                     break;
     31                    goto outer_loop;
    3132                }
    3233            }
    3334
    34             for (const PabloBlock * test = br->getParent(); test; test = test->getPredecessor()) {
    35                 // technically we should check whether this user dominates the branch but if it
    36                 // doesn't, then the program is illegal anyway and the error will be found.
     35            // Is there an assignment to this Var that dominates this branch?
     36            const Branch * check = br;
     37            for (const PabloBlock * test = br->getParent(); test; ) {
    3738                if (test == scope) {
    38                     if (inside) {
    39                         return true;
     39                    // verify this assignment actually dominates the branch
     40                    const Statement * temp1 = cast<Assign>(user);
     41                    const Statement * temp2 = check;
     42                    while (temp1 && temp2) {
     43                        if (temp1 == check) {
     44                            break;
     45                        } else if (temp2 == cast<Assign>(user)) {
     46                            temp1 = nullptr;
     47                            break;
     48                        }
     49                        temp1 = temp1->getNextNode();
     50                        temp2 = temp2->getNextNode();
    4051                    }
    41                     outside = true;
     52                    if (temp1 != nullptr) {
     53                        if (inside) {
     54                            return true;
     55                        }
     56                        outside = true;
     57                    }
    4258                    break;
    4359                }
     60                check = test->getBranch();
     61                if (LLVM_UNLIKELY(check == nullptr)) {
     62                    break;
     63                }
     64                test = check->getParent();
    4465            }
    45 
    4666        }
     67outer_loop: continue;
    4768    }
    4869    return false;
     
    5475std::vector<Var *> Branch::getEscaped() const {
    5576
    56     PabloFunction * const f = getParent()->getParent();
     77    const auto f = getParent()->getParent();
    5778    const auto n = f->getNumOfVariables();
    5879
  • icGREP/icgrep-devel/icgrep/pablo/builder.cpp

    r5202 r5217  
    9999}
    100100
     101inline void printType(const Type * type, raw_string_ostream & out) {
     102    if (auto st = dyn_cast<IDISA::StreamType>(type)) {
     103        out << "<" << st->getNumElements() << " x s" << st->getFieldWidth() << ">";
     104    } else {
     105        type->print(out);
     106    }
     107}
     108
    101109using TypeId = PabloAST::ClassTypeId;
    102110
     
    193201
    194202PabloAST * PabloBuilder::createAssign(PabloAST * const variable, PabloAST * const value) {
    195     MAKE_BINARY(createAssign, TypeId::Assign, variable, value);
    196     return result;
     203    if (variable->getType() != value->getType()) {
     204        std::string tmp;
     205        raw_string_ostream out(tmp);
     206        out << "Cannot assign ";
     207        value->print(out);
     208        out << " to ";
     209        variable->print(out);
     210        out << ": type of ";
     211        value->print(out);
     212        out << " ";
     213        printType(value->getType(), out);
     214        out << " does not match ";
     215        variable->print(out);
     216        out << " ";
     217        printType(variable->getType(), out);
     218        throw std::runtime_error(out.str());
     219    }
     220    return mPb->createAssign(variable, value);
    197221}
    198222
     
    399423}
    400424
     425PabloAST * PabloBuilder::createAdd(PabloAST * expr1, PabloAST * expr2) {
     426    if (isa<Integer>(expr1) && isa<Integer>(expr2)) {
     427        return getInteger(cast<Integer>(expr1)->value() + cast<Integer>(expr2)->value());
     428    }
     429    MAKE_BINARY(createAdd, TypeId::Add, expr1, expr2);
     430    return result;
     431}
     432
     433PabloAST * PabloBuilder::createAdd(PabloAST * expr1, PabloAST * expr2, const std::string & prefix) {
     434    if (isa<Integer>(expr1) && isa<Integer>(expr2)) {
     435        return getInteger(cast<Integer>(expr1)->value() + cast<Integer>(expr2)->value());
     436    }
     437    MAKE_NAMED_BINARY(createAdd, TypeId::Add, prefix, expr1, expr2);
     438    return result;
     439}
     440
     441PabloAST * PabloBuilder::createSubtract(PabloAST * expr1, PabloAST * expr2) {
     442    if (isa<Integer>(expr1) && isa<Integer>(expr2)) {
     443        return getInteger(cast<Integer>(expr1)->value() - cast<Integer>(expr2)->value());
     444    }
     445    MAKE_BINARY(createSubtract, TypeId::Subtract, expr1, expr2);
     446    return result;
     447}
     448
     449PabloAST * PabloBuilder::createSubtract(PabloAST * expr1, PabloAST * expr2, const std::string & prefix) {
     450    if (isa<Integer>(expr1) && isa<Integer>(expr2)) {
     451        return getInteger(cast<Integer>(expr1)->value() - cast<Integer>(expr2)->value());
     452    }
     453    MAKE_NAMED_BINARY(createSubtract, TypeId::Subtract, prefix, expr1, expr2);
     454    return result;
     455}
     456
    401457PabloAST * PabloBuilder::createInFile(PabloAST * expr) {
    402458    MAKE_UNARY(createInFile, TypeId::InFile, expr);
  • icGREP/icgrep-devel/icgrep/pablo/builder.hpp

    r5202 r5217  
    8181    Extract * createExtract(PabloAST * value, not_null<PabloAST *> index);
    8282
    83     inline Extract * createExtract(PabloAST * value, const Integer::Type index) {
     83    inline Extract * createExtract(PabloAST * value, const int64_t index) {
    8484        return createExtract(value, getInteger(index));
    8585    }
     
    8787    Extract * createExtract(PabloAST * value, not_null<PabloAST *> index, const std::string & prefix);
    8888
    89     inline Extract * createExtract(PabloAST * value, const Integer::Type index, const std::string & prefix) {
     89    inline Extract * createExtract(PabloAST * value, const int64_t index, const std::string & prefix) {
    9090        return createExtract(value, getInteger(index), prefix);
    9191    }
     
    9797    Call * createCall(Prototype * prototype, const std::vector<PabloAST *> &vars);
    9898
    99     inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount) {
     99    inline PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount) {
    100100        return createAdvance(expr, mPb->getInteger(shiftAmount));
    101101    }
     
    103103    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount);
    104104
    105     inline PabloAST * createAdvance(PabloAST * expr, const Integer::Type shiftAmount, const std::string & prefix) {
     105    inline PabloAST * createAdvance(PabloAST * expr, const int64_t shiftAmount, const std::string & prefix) {
    106106        return createAdvance(expr, mPb->getInteger(shiftAmount), prefix);
    107107    }
     
    109109    PabloAST * createAdvance(PabloAST * expr, PabloAST * shiftAmount, const std::string & prefix);
    110110
    111     inline PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount) {
     111    inline PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount) {
    112112        if (shiftAmount == 0) {
    113113            return expr;
     
    118118    PabloAST * createLookahead(PabloAST * expr, PabloAST * shiftAmount);
    119119
    120     inline PabloAST * createLookahead(PabloAST * expr, const Integer::Type shiftAmount, const std::string & prefix) {
     120    inline PabloAST * createLookahead(PabloAST * expr, const int64_t shiftAmount, const std::string & prefix) {
    121121        if (shiftAmount == 0) {
    122122            return expr;
     
    169169    PabloAST * createAtEOF(PabloAST * expr, const std::string & prefix);
    170170   
     171    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2);
     172
     173    PabloAST * createAdd(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
     174
     175    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2);
     176
     177    PabloAST * createSubtract(PabloAST * expr1, PabloAST * expr2, const std::string & prefix);
     178
    171179    inline If * createIf(PabloAST * condition, PabloBlock * body) {
    172180        return mPb->createIf(condition, body);
     
    231239    }
    232240
    233     inline String * getName(const std::string name) const {
     241    inline String * getName(const std::string & name) const {
    234242        return mPb->getName(name);
    235243    }
     
    239247    }
    240248
    241     inline Integer * getInteger(Integer::Type value) const {
     249    inline Integer * getInteger(const uint64_t value) const {
    242250        return mPb->getInteger(value);
    243     }
    244 
    245     inline SymbolGenerator * getSymbolTable() const {
    246         return mPb->getSymbolTable();
    247251    }
    248252
  • icGREP/icgrep-devel/icgrep/pablo/carry_manager.cpp

    r5202 r5217  
    2222 * @brief initializeCarryData
    2323 ** ------------------------------------------------------------------------------------------------------------- */
    24 Type * CarryManager::initializeCarryData(PabloFunction * const function) {
    25     mRootScope = function->getEntryBlock();
     24Type * CarryManager::initializeCarryData(PabloKernel * const kernel) {
     25    mRootScope = kernel->getEntryBlock();
    2626    mCarryInfoVector.resize(mRootScope->enumerateScopes(0) + 1);
    2727    mCarryPackType = mBitBlockType;
     
    4040 * @brief initializeCodeGen
    4141 ** ------------------------------------------------------------------------------------------------------------- */
    42 void CarryManager::initializeCodeGen(PabloKernel * const kBuilder, Value * selfPtr) {
    43     mKernelBuilder = kBuilder;
     42void CarryManager::initializeCodeGen(PabloKernel * const kernel, Value * selfPtr) {
     43    mKernelBuilder = kernel;
    4444    mSelf = selfPtr;
    4545   
     
    399399    Type * summaryTy = summary->getType();
    400400    Type * valueTy = value->getType();
     401
    401402    if (LLVM_UNLIKELY(isa<Constant>(value))) {
    402403        if (LLVM_LIKELY(cast<Constant>(value)->isZeroValue())) return;
     
    406407        }
    407408    }
     409
    408410    Value * v = value;
    409411    if (valueTy != summaryTy) {
  • icGREP/icgrep-devel/icgrep/pablo/carry_manager.h

    r5115 r5217  
    5959    ~CarryManager();
    6060   
    61     Type * initializeCarryData(PabloFunction * const function);
    62     void initializeCodeGen(PabloKernel * const kBuilder, Value * selfPtr);
     61    Type * initializeCarryData(PabloKernel * const kernel);
     62    void initializeCodeGen(PabloKernel * const kernel, Value * selfPtr);
    6363
    6464    void reset();
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

    r5202 r5217  
    66
    77#include <pablo/codegenstate.h>
    8 #include <pablo/printer_pablos.h>
     8
     9#define CHECK_SAME_TYPE(A, B) \
     10    assert ("DIFFERING CONTEXTS" && (&((A)->getType()->getContext()) == &((B)->getType()->getContext()))); \
     11    assert ("DIFFERING TYPES" && ((A)->getType() == (B)->getType()))
     12
     13using StreamType = IDISA::StreamType;
    914
    1015namespace pablo {
     
    1924
    2025Count * PabloBlock::createCount(PabloAST * expr) {
    21     return insertAtInsertionPoint(new Count(expr, makeName("count")));
     26    Type * type = getParent()->getBuilder()->getSizeTy();
     27    return insertAtInsertionPoint(new Count(expr, makeName("count"), type));
    2228}
    2329
    2430Count * PabloBlock::createCount(PabloAST * const expr, const std::string & prefix)  {
    25     return insertAtInsertionPoint(new Count(expr, makeName(prefix)));
     31    Type * type = getParent()->getBuilder()->getSizeTy();
     32    return insertAtInsertionPoint(new Count(expr, makeName(prefix), type));
    2633}
    2734
     
    3643Var * PabloBlock::createVar(PabloAST * name, Type * type) {
    3744    if (type == nullptr) {
    38         type = getStreamTy();
     45        type = getParent()->getStreamSetTy();
    3946    }
    4047    if (LLVM_UNLIKELY(name == nullptr || !isa<String>(name))) {
     
    7986Extract * PabloBlock::createExtract(PabloAST * array, PabloAST * index, String * name) {
    8087    assert (array && index);
    81     if (LLVM_LIKELY(isa<ArrayType>(array->getType()))) {
    82         if (name == nullptr) {
    83             std::string tmp;
    84             raw_string_ostream out(tmp);
    85             PabloPrinter::print(array, out);
    86             PabloPrinter::print(index, out);
    87             name = makeName(out.str());
    88         }
    89         return insertAtInsertionPoint(new Extract(array, index, name));
     88    if (name == nullptr) {
     89        std::string tmp;
     90        raw_string_ostream out(tmp);
     91        array->print(out);
     92        out << '[';
     93        index->print(out);
     94        out << ']';
     95        name = makeName(out.str());
     96    }
     97    llvm::Type * const type = array->getType();
     98    if (LLVM_LIKELY(isa<StreamType>(type))) {
     99        Type * elementType = cast<StreamType>(type)->getStreamElementType();
     100        return insertAtInsertionPoint(new Extract(array, index, name, elementType));
     101    }
     102    if (LLVM_LIKELY(isa<ArrayType>(type))) {
     103        Type * elementType = cast<ArrayType>(type)->getArrayElementType();
     104        return insertAtInsertionPoint(new Extract(array, index, name, elementType));
    90105    }
    91106    std::string tmp;
     
    93108    out << "cannot extract element from ";
    94109    array->print(out);
    95     out << ": type is not a valid ArrayType";
     110    out << " : not a StreamType or ArrayType";
    96111    throw std::runtime_error(out.str());
    97112}
    98113
    99114And * PabloBlock::createAnd(PabloAST * expr1, PabloAST * expr2, String * name) {
     115    CHECK_SAME_TYPE(expr1, expr2);
    100116    if (name == nullptr) {
    101117        name = makeName("and");
     
    112128
    113129Or * PabloBlock::createOr(PabloAST * expr1, PabloAST * expr2, String * name) {
     130    CHECK_SAME_TYPE(expr1, expr2);
    114131    if (name == nullptr) {
    115132        name = makeName("or");
     
    126143
    127144Xor * PabloBlock::createXor(PabloAST * expr1, PabloAST * expr2, String * name) {
     145    CHECK_SAME_TYPE(expr1, expr2);
    128146    if (name == nullptr) {
    129147        name = makeName("xor");
     
    139157}
    140158
     159Add * PabloBlock::createAdd(PabloAST * expr1, PabloAST * expr2, String * name) {
     160    CHECK_SAME_TYPE(expr1, expr2);
     161    if (name == nullptr) {
     162        name = makeName("add");
     163    }
     164    return insertAtInsertionPoint(new Add(expr1->getType(), expr1, expr2, name));
     165}
     166
     167Subtract * PabloBlock::createSubtract(PabloAST * expr1, PabloAST * expr2, String * name) {
     168    CHECK_SAME_TYPE(expr1, expr2);
     169    if (name == nullptr) {
     170        name = makeName("sub");
     171    }
     172    return insertAtInsertionPoint(new Subtract(expr1->getType(), expr1, expr2, name));
     173}
     174
    141175Assign * PabloBlock::createAssign(PabloAST * const var, PabloAST * const value) {
     176    CHECK_SAME_TYPE(var, value);
    142177    return insertAtInsertionPoint(new Assign(var, value));
    143178}
    144179
    145180MatchStar * PabloBlock::createMatchStar(PabloAST * marker, PabloAST * charclass, String * name) {
     181    CHECK_SAME_TYPE(marker, charclass);
    146182    if (name == nullptr) {
    147183        name = makeName("matchstar");
     
    151187
    152188ScanThru * PabloBlock::createScanThru(PabloAST * from, PabloAST * thru, String * name) {
     189    CHECK_SAME_TYPE(from, thru);
    153190    if (name == nullptr) {
    154191        name = makeName("scanthru");
     
    174211
    175212Sel * PabloBlock::createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * name) {
     213    CHECK_SAME_TYPE(trueExpr, falseExpr);
    176214    if (name == nullptr) {
    177215        name = makeName("sel");
     
    230268    return nextScopeIndex;
    231269}   
    232    
    233 /// CONSTRUCTOR
    234 
    235 PabloBlock::PabloBlock(PabloFunction * const parent) noexcept
    236 : PabloAST(PabloAST::ClassTypeId::Block, nullptr, nullptr)
    237 , mParent(parent)
    238 , mBranch(nullptr)
    239 , mScopeIndex(0)
    240 {
    241 
    242 }
    243 
    244 PabloBlock::~PabloBlock() {
    245 
    246 }
    247 
    248 }
     270
     271}
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r5202 r5217  
    1010#include <pablo/pabloAST.h>
    1111#include <pablo/symbol_generator.h>
     12#include <pablo/boolean.h>
     13#include <pablo/arithmetic.h>
     14#include <pablo/branch.h>
     15
    1216#include <pablo/pe_advance.h>
    1317#include <pablo/pe_lookahead.h>
    14 #include <pablo/pe_and.h>
    15 #include <pablo/pe_call.h>
    1618#include <pablo/pe_matchstar.h>
    17 #include <pablo/pe_not.h>
    18 #include <pablo/pe_ones.h>
    19 #include <pablo/pe_or.h>
    2019#include <pablo/pe_scanthru.h>
    21 #include <pablo/pe_sel.h>
    2220#include <pablo/pe_infile.h>
     21
     22#include <pablo/pe_count.h>
     23
    2324#include <pablo/pe_integer.h>
    2425#include <pablo/pe_string.h>
     26#include <pablo/pe_zeroes.h>
     27#include <pablo/pe_ones.h>
     28
    2529#include <pablo/pe_var.h>
    26 #include <pablo/pe_xor.h>
    27 #include <pablo/pe_zeroes.h>
    28 #include <pablo/pe_count.h>
    2930#include <pablo/ps_assign.h>
    30 #include <pablo/branch.h>
    31 #include <pablo/function.h>
     31
     32#include <pablo/pe_call.h>
     33
     34#include <pablo/pablo_kernel.h>
     35
    3236#include <llvm/ADT/ArrayRef.h>
    3337#include <stdexcept>
    3438
    3539namespace pablo {
     40
     41class PabloKernel;
    3642
    3743class PabloBlock : public PabloAST, public StatementList {
     
    5460    }
    5561
    56     inline static PabloBlock * Create(PabloFunction & parent) noexcept {
    57         return new PabloBlock(&parent);
     62    inline static PabloBlock * Create(PabloKernel * const parent) noexcept {
     63        return new PabloBlock(parent);
    5864    }
    5965
     
    146152    AtEOF * createAtEOF(PabloAST * expr, String * const name);
    147153
    148     Extract * createExtract(PabloAST * array, const Integer::Type index) {
     154    Extract * createExtract(PabloAST * array, const int64_t index) {
    149155        return createExtract(array, getInteger(index), nullptr);
    150156    }
     
    158164    }
    159165
    160     Extract * createExtract(PabloAST * array, const Integer::Type index, const std::string & prefix) {
     166    Extract * createExtract(PabloAST * array, const int64_t index, const std::string & prefix) {
    161167        return createExtract(array, getInteger(index), makeName(prefix));
    162168    }
     
    214220    Xor * createXor(Type * const type, const unsigned reserved, String * const name);
    215221
     222    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
     223        return createSel(condition, trueExpr, falseExpr, nullptr);
     224    }
     225
     226    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string & prefix) {
     227        return createSel(condition, trueExpr, falseExpr, makeName(prefix));
     228    }
     229
     230    Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * const name);
     231
     232    Add * createAdd(PabloAST * expr1, PabloAST * expr2) {
     233        return createAdd(expr1, expr2, nullptr);
     234    }
     235
     236    Add * createAdd(PabloAST * expr1, PabloAST * expr2, const std::string & prefix) {
     237        return createAdd(expr1, expr2, makeName(prefix));
     238    }
     239
     240    Add * createAdd(PabloAST * expr1, PabloAST * expr2, String * const name);
     241
     242    Subtract * createSubtract(PabloAST * expr1, PabloAST * expr2) {
     243        return createSubtract(expr1, expr2, nullptr);
     244    }
     245
     246    Subtract * createSubtract(PabloAST * expr1, PabloAST * expr2, const std::string & prefix) {
     247        return createSubtract(expr1, expr2, makeName(prefix));
     248    }
     249
     250    Subtract * createSubtract(PabloAST * expr1, PabloAST * expr2, String * const name);
     251
    216252    MatchStar * createMatchStar(PabloAST * marker, PabloAST * charclass) {
    217253        return createMatchStar(marker, charclass, nullptr);
     
    234270    ScanThru * createScanThru(PabloAST * from, PabloAST * thru, String * const name);
    235271
    236     Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
    237         return createSel(condition, trueExpr, falseExpr, nullptr);
    238     }
    239 
    240     Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, const std::string & prefix) {
    241         return createSel(condition, trueExpr, falseExpr, makeName(prefix));
    242     }
    243 
    244     Sel * createSel(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr, String * const name);
    245    
    246272    If * createIf(PabloAST * condition, PabloBlock * body);
    247273
     
    252278    }
    253279
    254     inline PabloFunction * getParent() const {
     280    inline PabloKernel * getParent() const {
    255281        return mParent;
    256     }
    257 
    258     void setParent(PabloFunction * const parent) {
    259         mParent = parent;
    260282    }
    261283
     
    278300    }
    279301
    280     inline String * getName(const std::string name) const {
    281         return getSymbolTable()->get(name);
     302    inline String * getName(const std::string & name) const {
     303        return mParent->getName(name);
    282304    }
    283305
    284306    inline String * makeName(const std::string & prefix) const {
    285         return getSymbolTable()->make(prefix);
    286     }
    287 
    288     inline Integer * getInteger(Integer::Type value) const {
    289         return getSymbolTable()->getInteger(value);
    290     }
    291 
    292     SymbolGenerator * getSymbolTable() const {
    293         return mParent->getSymbolTable();
    294     }
    295 
    296     virtual ~PabloBlock();
     307        return mParent->makeName(prefix);
     308    }
     309
     310    inline Integer * getInteger(const int64_t value) const {
     311        return mParent->getInteger(value);
     312    }
     313
     314    virtual ~PabloBlock() {}
    297315
    298316protected:
    299317
    300     explicit PabloBlock(PabloFunction * parent) noexcept;
     318    explicit PabloBlock(PabloKernel * const parent) noexcept
     319    : PabloAST(PabloAST::ClassTypeId::Block, nullptr, nullptr)
     320    , mParent(parent)
     321    , mBranch(nullptr)
     322    , mScopeIndex(0) {
     323
     324    }
    301325
    302326    template<typename Type>
     
    313337
    314338private:       
    315     PabloFunction *                                     mParent;
    316     Branch *                                            mBranch;
    317     unsigned                                            mScopeIndex;
     339    PabloKernel * const         mParent;
     340    Branch *                    mBranch;
     341    unsigned                    mScopeIndex;
    318342};
    319343
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/codemotionpass.cpp

    r5202 r5217  
    11#include "codemotionpass.h"
     2#include <pablo/pablo_kernel.h>
    23#include <pablo/codegenstate.h>
    34#include <pablo/analysis/pabloverifier.hpp>
    45#include <boost/container/flat_set.hpp>
    5 #include <boost/container/flat_map.hpp>
    6 #include <boost/graph/adjacency_list.hpp>
    7 #include <boost/graph/topological_sort.hpp>
    8 #include <boost/circular_buffer.hpp>
     6// #include <boost/circular_buffer.hpp>
    97
    108using namespace boost;
     
    1614 * @brief optimize
    1715 ** ------------------------------------------------------------------------------------------------------------- */
    18 bool CodeMotionPass::optimize(PabloFunction & function) {
    19     CodeMotionPass::movement(function.getEntryBlock());
     16bool CodeMotionPass::optimize(PabloKernel * kernel) {
     17    CodeMotionPass::movement(kernel->getEntryBlock());
    2018    #ifndef NDEBUG
    21     PabloVerifier::verify(function, "post-code-motion");
     19    PabloVerifier::verify(kernel, "post-code-motion");
    2220    #endif
    2321    return true;
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/codemotionpass.h

    r5202 r5217  
    77namespace pablo {
    88
    9 class PabloFunction;
     9class PabloKernel;
    1010class PabloBlock;
    1111class Statement;
     
    2929    };
    3030public:
    31     static bool optimize(PabloFunction & function);
     31    static bool optimize(PabloKernel * kernel);
    3232protected:
    3333    static void movement(PabloBlock * const block);
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_automultiplexing.cpp

    r5202 r5217  
    11#include "pablo_automultiplexing.hpp"
    22#include <pablo/builder.hpp>
    3 #include <pablo/function.h>
     3#include <pablo/prototype.h>
    44#include <pablo/printer_pablos.h>
    55#include <boost/container/flat_set.hpp>
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.cpp

    r5202 r5217  
    11#include <pablo/optimizers/pablo_simplifier.hpp>
     2#include <pablo/pablo_kernel.h>
    23#include <pablo/codegenstate.h>
    34#include <pablo/expression_map.hpp>
    4 #include <pablo/function.h>
     5//#include <pablo/function.h>
    56#include <pablo/analysis/pabloverifier.hpp>
    6 #include <boost/container/flat_set.hpp>
    7 #include <boost/container/flat_map.hpp>
     7//#include <boost/container/flat_set.hpp>
     8//#include <boost/container/flat_map.hpp>
    89#include <pablo/printer_pablos.h>
    9 #include <iostream>
     10//#include <iostream>
    1011
    1112using namespace boost;
     
    559560 * @brief deadCodeElimination
    560561 ** ------------------------------------------------------------------------------------------------------------- */
    561 void Simplifier::deadCodeElimination(PabloFunction & f) {
    562 
    563     deadCodeElimination(f.getEntryBlock());
    564 
    565     for (unsigned i = 0; i < f.getNumOfVariables(); ++i) {
    566         Var * var = f.getVariable(i);
     562void Simplifier::deadCodeElimination(PabloKernel * kernel) {
     563
     564    deadCodeElimination(kernel->getEntryBlock());
     565
     566    for (unsigned i = 0; i < kernel->getNumOfVariables(); ++i) {
     567        Var * var = kernel->getVariable(i);
    567568        bool unused = true;
    568569        for (PabloAST * user : var->users()) {
     
    642643 * @brief optimize
    643644 ** ------------------------------------------------------------------------------------------------------------- */
    644 bool Simplifier::optimize(PabloFunction & function) {
    645     redundancyElimination(function.getEntryBlock());
    646     strengthReduction(function.getEntryBlock());
    647     deadCodeElimination(function);
     645bool Simplifier::optimize(PabloKernel * kernel) {
     646    redundancyElimination(kernel->getEntryBlock());
     647    strengthReduction(kernel->getEntryBlock());
     648    deadCodeElimination(kernel);
    648649    #ifndef NDEBUG
    649     PabloVerifier::verify(function, "post-simplification");
     650    PabloVerifier::verify(kernel, "post-simplification");
    650651    #endif
    651652    return true;
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_simplifier.hpp

    r5202 r5217  
    22#define PABLO_SIMPLIFIER_HPP
    33
    4 #include <pablo/codegenstate.h>
    5 
    64namespace pablo {
    75
    8 class PabloFunction;
     6class PabloKernel;
     7class PabloAST;
     8class Variadic;
     9class Statement;
     10class PabloBlock;
     11
    912struct ExpressionTable;
    1013
     
    1316    struct VariableTable;
    1417public:
    15     static bool optimize(PabloFunction & function);
     18    static bool optimize(PabloKernel * kernel);
    1619protected:
    1720    Simplifier() = default;
     
    2023    static PabloAST * fold(Statement * const stmt, PabloBlock * const block);
    2124    static void redundancyElimination(PabloBlock * const block, ExpressionTable * et = nullptr, VariableTable * const vt = nullptr);
    22     static void deadCodeElimination(PabloFunction & f);
     25    static void deadCodeElimination(PabloKernel * const kernel);
    2326    static void deadCodeElimination(PabloBlock * const block);
    2427    static void strengthReduction(PabloBlock * const block);
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r5202 r5217  
    88#define PE_PabloAST_H
    99
    10 #include <pablo/type/streamtype.h>
     10#include <IDISA/types/streamtype.h>
    1111#include <llvm/Support/Casting.h>
    1212#include <llvm/Support/Compiler.h>
     
    3636    friend class Count;
    3737    friend class Var;
    38     friend void addUsage(PabloAST *, PabloBlock *);
    39     friend void removeUsage(PabloAST *, PabloBlock *);
    4038public:
    4139
     
    8179        // Statistics operations
    8280        , Count
     81        // Arithmetic operations
     82        , Add
     83        , Subtract
    8384        // Variable assignments
    8485        , Assign
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r5204 r5217  
    1010#include <pablo/carry_manager.h>
    1111#include <pablo/printer_pablos.h>
    12 #include <pablo/function.h>
     12#include <pablo/prototype.h>
    1313#include <re/re_name.h>
    1414#include <stdexcept>
     
    2323namespace pablo {
    2424
    25 PabloCompiler::PabloCompiler(PabloKernel * k, PabloFunction * const function)
    26 : iBuilder(k->getBuilder())
     25PabloCompiler::PabloCompiler(PabloKernel * kernel)
     26: iBuilder(kernel->getBuilder())
    2727, mBitBlockType(iBuilder->getBitBlockType())
    2828, mCarryManager(nullptr)
    29 , mPabloFunction(function)
    30 , mKernelBuilder(k)
     29, mKernel(kernel)
    3130, mWhileDepth(0)
    3231, mIfDepth(0)
     
    3736
    3837Type * PabloCompiler::initializeKernelData() {
    39     Examine(mPabloFunction);   
     38    Examine();
    4039    mCarryManager = std::unique_ptr<CarryManager>(new CarryManager(iBuilder));
    41     Type * carryDataType = mCarryManager->initializeCarryData(mPabloFunction);
    42     return carryDataType;
    43 }
    44    
    45 void PabloCompiler::verifyParameter(const Var * var, const Value * param) {
    46     if (LLVM_UNLIKELY(&(param->getContext()) != &(iBuilder->getContext()))) {
    47         std::string tmp;
    48         raw_string_ostream out(tmp);
    49         out << "Cannot compile ";
    50         mPabloFunction->print(out);
    51         out << ": LLVM Context for ";
    52         var->print(out);
    53         out << " differs from that of the kernel.";
    54         throw std::runtime_error(out.str());
    55     }
    56 }
    57 
    58 void PabloCompiler::compile(Function * doBlockFunction) {
     40    return mCarryManager->initializeCarryData(mKernel);
     41}
     42   
     43void PabloCompiler::compile(Value * const self, Function * doBlockFunction) {
    5944
    6045    // Make sure that we generate code into the right module.
    6146    mFunction = doBlockFunction;
     47    mSelf = self;
     48
    6249    #ifdef PRINT_TIMING_INFORMATION
    6350    const timestamp_t pablo_compilation_start = read_cycle_counter();
     
    6653    //Generate Kernel//
    6754    iBuilder->SetInsertPoint(BasicBlock::Create(iBuilder->getContext(), "entry", doBlockFunction, 0));
    68     mSelf = mKernelBuilder->getParameter(doBlockFunction, "self");
    69 
    70     mCarryManager->initializeCodeGen(mKernelBuilder, mSelf);
     55
     56    mCarryManager->initializeCodeGen(mKernel, mSelf);
    7157     
    72     PabloBlock * const entryBlock = mPabloFunction->getEntryBlock(); assert (entryBlock);
     58    PabloBlock * const entryBlock = mKernel->getEntryBlock(); assert (entryBlock);
    7359    mMarkerMap.emplace(entryBlock->createZeroes(), iBuilder->allZeroes());
    7460    mMarkerMap.emplace(entryBlock->createOnes(), iBuilder->allOnes());
    7561
    76     Value * const blockNo = mKernelBuilder->getScalarField(mSelf, blockNoScalar);
    77 
    78     for (unsigned i = 0, j = 0; i < mPabloFunction->getNumOfParameters(); ++i) {
    79         Var * var = mPabloFunction->getParameter(i);
     62    Value * const blockNo = mKernel->getScalarField(mSelf, blockNoScalar);
     63
     64    for (unsigned i = 0; i < mKernel->getNumOfInputs(); ++i) {
     65        Var * var = mKernel->getInput(i);
    8066        std::string name = var->getName()->to_string();
    8167        Value * input = nullptr;
    8268        if (var->getType()->isSingleValueType()) {
    83             input = mKernelBuilder->getScalarFieldPtr(mSelf, name);
     69            input = mKernel->getScalarFieldPtr(mSelf, name);
    8470        } else {
    85             input = mKernelBuilder->getStreamSetBlockPtr(mSelf, name, blockNo);
    86             input = iBuilder->CreateGEP(input, {iBuilder->getInt32(0), iBuilder->getInt32(j++)});
    87         }
    88         verifyParameter(var, input);
     71            input = mKernel->getStreamSetBlockPtr(mSelf, name, blockNo);
     72        }
    8973        mMarkerMap.emplace(var, input);
    9074    }
    9175
    92     for (unsigned i = 0, j = 0; i < mPabloFunction->getNumOfResults(); ++i) {
    93         Var * var = mPabloFunction->getResult(i);
     76    for (unsigned i = 0; i < mKernel->getNumOfOutputs(); ++i) {
     77        Var * var = mKernel->getOutput(i);
    9478        std::string name = var->getName()->to_string();
    9579        Value * output = nullptr;
    9680        if (var->getType()->isSingleValueType()) {
    97             output = mKernelBuilder->getScalarFieldPtr(mSelf, name);
     81            output = mKernel->getScalarFieldPtr(mSelf, name);
    9882        } else {
    99             output = mKernelBuilder->getStreamSetBlockPtr(mSelf, name, blockNo);
    100             output = iBuilder->CreateGEP(output, {iBuilder->getInt32(0), iBuilder->getInt32(j++)});
    101         }
    102         verifyParameter(var, output);
     83            output = mKernel->getStreamSetBlockPtr(mSelf, name, blockNo);
     84        }
    10385        mMarkerMap.emplace(var, output);
    10486    }
     
    11294}
    11395
    114 inline void PabloCompiler::Examine(const PabloFunction * const function) {
     96inline void PabloCompiler::Examine() {
    11597    mWhileDepth = 0;
    11698    mIfDepth = 0;
    11799    mMaxWhileDepth = 0;
    118     Examine(function->getEntryBlock());
     100    Examine(mKernel->getEntryBlock());
    119101}
    120102
     
    124106            const Lookahead * const la = cast<Lookahead>(stmt);
    125107            assert (isa<Var>(la->getExpr()));
    126             if (LLVM_LIKELY(la->getAmount() > mKernelBuilder->getLookAhead())) {
    127                 mKernelBuilder->setLookAhead(la->getAmount());
     108            if (LLVM_LIKELY(la->getAmount() > mKernel->getLookAhead())) {
     109                mKernel->setLookAhead(la->getAmount());
    128110            }
    129111        } else {
     
    277259
    278260    // for any Next nodes in the loop body, initialize to (a) pre-loop value.
    279     for (const auto var : whileStatement->getEscaped()) {
    280         PHINode * phi = iBuilder->CreatePHI(mBitBlockType, 2, getName(var));
     261    for (const auto var : whileStatement->getEscaped()) {       
    281262        auto f = mMarkerMap.find(var);
    282263        if (LLVM_UNLIKELY(f == mMarkerMap.end())) {
     
    284265            raw_string_ostream out(tmp);
    285266            PabloPrinter::print(var, out);
    286             out << " was not assigned a value.";
     267            out << " is uninitialized prior to entering ";
     268            PabloPrinter::print(whileStatement, out);
    287269            llvm::report_fatal_error(out.str());
    288270        }
     271
     272        PHINode * phi = iBuilder->CreatePHI(mBitBlockType, 2, getName(var));
    289273        phi->addIncoming(f->second, whileEntryBlock);
    290274        f->second = phi;
     
    362346            bool storeInstRequired = false;
    363347            if (LLVM_LIKELY(isa<Var>(expr))) {
    364                 for (unsigned i = 0; i < mPabloFunction->getNumOfResults(); ++i) {
    365                     if (expr == mPabloFunction->getResult(i)) {
     348                for (unsigned i = 0; i < mKernel->getNumOfOutputs(); ++i) {
     349                    if (expr == mKernel->getOutput(i)) {
    366350                        storeInstRequired = true;
    367351                        break;
     
    371355
    372356            if (LLVM_UNLIKELY(storeInstRequired || isa<Extract>(expr))) {
    373 
    374357                const auto f = mMarkerMap.find(expr);
    375358                if (LLVM_UNLIKELY(f == mMarkerMap.end())) {
    376359                    std::string tmp;
    377360                    raw_string_ostream out(tmp);
    378                     PabloPrinter::print(expr, out);
    379                     out << " was not defined prior to ";
    380                     PabloPrinter::print(stmt, out);
     361                    out << "Use-before-definition error: ";
     362                    expr->print(out);
     363                    out << " does not dominate ";
     364                    stmt->print(out);
    381365                    throw std::runtime_error(out.str());
    382366                }
     
    389373                    value = iBuilder->CreateTruncOrBitCast(value, count->getType());
    390374                    value = iBuilder->CreateAdd(value, count);
     375                }
     376
     377//                cast<PointerType>(ptr->getType())->getElementType()->getPrimitiveSizeInBits() / 8;
     378
     379                const Type * const type = value->getType();
     380                if (isa<VectorType>(type) || isa<IntegerType>(type)) {
     381                    const auto bitWidth = isa<VectorType>(type)
     382                            ? cast<VectorType>(type)->getBitWidth()
     383                            : cast<IntegerType>(type)->getBitWidth();
     384                    iBuilder->CreateAlignedStore(value, ptr, bitWidth / 8);
     385                } else {
    391386                    iBuilder->CreateStore(value, ptr);
    392                 } else {
    393                     iBuilder->CreateBlockAlignedStore(value, ptr);
    394387                }
    395388            }
     
    398391            Value * array = compileExpression(extract->getArray(), false);
    399392            Value * index = compileExpression(extract->getIndex());
    400             value = iBuilder->CreateGEP(array, index, getName(stmt));
     393            value = iBuilder->CreateGEP(array, {ConstantInt::getNullValue(index->getType()), index}, getName(stmt));
    401394        } else if (const And * pablo_and = dyn_cast<And>(stmt)) {
    402395            value = iBuilder->simd_and(compileExpression(pablo_and->getOperand(0)), compileExpression(pablo_and->getOperand(1)));
     
    427420            value = iBuilder->simd_and(sum, iBuilder->simd_not(cc_expr));
    428421        } else if (const InFile * e = dyn_cast<InFile>(stmt)) {
    429             Value * EOFmask = mKernelBuilder->getScalarField(mSelf, "EOFmask");
     422            Value * EOFmask = mKernel->getScalarField(mSelf, "EOFmask");
    430423            value = iBuilder->simd_xor(compileExpression(e->getExpr()), EOFmask);
    431424        } else if (const AtEOF * e = dyn_cast<AtEOF>(stmt)) {
    432             Value * EOFbit = mKernelBuilder->getScalarField(mSelf, "EOFbit");
     425            Value * EOFbit = mKernel->getScalarField(mSelf, "EOFbit");
    433426            value = iBuilder->simd_and(compileExpression(e->getExpr()), EOFbit);
    434427        } else if (const Count * c = dyn_cast<Count>(stmt)) {
    435428            Value * const to_count = compileExpression(c->getExpr());
    436             const unsigned counterSize = 64;
    437             Value * fieldCounts = iBuilder->simd_popcount(counterSize, to_count);
    438             value = iBuilder->mvmd_extract(counterSize, fieldCounts, 0);
    439             for (unsigned i = 1; i < (iBuilder->getBitBlockWidth() / counterSize); ++i) {
    440                 Value * temp = iBuilder->mvmd_extract(counterSize, fieldCounts, i);
    441                 value = iBuilder->CreateAdd(value, temp);
     429            const unsigned counterSize = iBuilder->getSizeTy()->getBitWidth();
     430            Value * const partial = iBuilder->simd_popcount(counterSize, to_count);
     431            if (LLVM_UNLIKELY(counterSize <= 1)) {
     432                value = partial;
     433            } else {
     434                value = iBuilder->mvmd_extract(counterSize, partial, 0);
     435                const auto fields = (iBuilder->getBitBlockWidth() / counterSize);
     436                for (unsigned i = 1; i < fields; ++i) {
     437                    Value * temp = iBuilder->mvmd_extract(counterSize, partial, i);
     438                    value = iBuilder->CreateAdd(value, temp);
     439                }
    442440            }
    443441        } else if (const Lookahead * l = dyn_cast<Lookahead>(stmt)) {
     
    447445            }
    448446            unsigned index = 0;
    449             for (; index < mPabloFunction->getNumOfParameters(); ++index) {
    450                 if (mPabloFunction->getParameter(index) == var) {
     447            for (; index < mKernel->getNumOfInputs(); ++index) {
     448                if (mKernel->getInput(index) == var) {
    451449                    break;
    452450                }
    453451            }
    454             if (LLVM_UNLIKELY(index >= mPabloFunction->getNumOfParameters())) {
     452            if (LLVM_UNLIKELY(index >= mKernel->getNumOfInputs())) {
    455453                throw std::runtime_error("Lookahead has an illegal Var operand");
    456454            }
     
    458456            const unsigned block_shift = (l->getAmount() / iBuilder->getBitBlockWidth());
    459457            std::string inputName = var->getName()->to_string();;
    460             Value * blockNo = mKernelBuilder->getScalarField(mSelf, blockNoScalar);
    461             Value * lookAhead_blockPtr  = mKernelBuilder->getStreamSetBlockPtr(mSelf, inputName, iBuilder->CreateAdd(blockNo, ConstantInt::get(iBuilder->getSizeTy(), block_shift)));
     458            Value * blockNo = mKernel->getScalarField(mSelf, blockNoScalar);
     459            Value * lookAhead_blockPtr  = mKernel->getStreamSetBlockPtr(mSelf, inputName, iBuilder->CreateAdd(blockNo, ConstantInt::get(iBuilder->getSizeTy(), block_shift)));
    462460            Value * lookAhead_inputPtr = iBuilder->CreateGEP(lookAhead_blockPtr, {iBuilder->getInt32(0), iBuilder->getInt32(index)});
    463461            Value * lookAhead = iBuilder->CreateBlockAlignedLoad(lookAhead_inputPtr);
     
    465463                value = lookAhead;
    466464            } else { // Need to form shift result from two adjacent blocks.
    467                 Value * lookAhead_blockPtr1  = mKernelBuilder->getStreamSetBlockPtr(mSelf, inputName, iBuilder->CreateAdd(blockNo, ConstantInt::get(iBuilder->getSizeTy(), block_shift + 1)));
     465                Value * lookAhead_blockPtr1  = mKernel->getStreamSetBlockPtr(mSelf, inputName, iBuilder->CreateAdd(blockNo, ConstantInt::get(iBuilder->getSizeTy(), block_shift + 1)));
    468466                Value * lookAhead_inputPtr1 = iBuilder->CreateGEP(lookAhead_blockPtr1, {iBuilder->getInt32(0), iBuilder->getInt32(index)});
    469467                Value * lookAhead1 = iBuilder->CreateBlockAlignedLoad(lookAhead_inputPtr1);
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.h

    r5202 r5217  
    4848    using MarkerMap = std::unordered_map<const PabloAST *, Value *>;
    4949public:
    50     PabloCompiler(PabloKernel * k, PabloFunction * function);
     50    PabloCompiler(PabloKernel * kernel);
    5151    Type * initializeKernelData();
    52     void compile(Function * doBlockFunction);
     52    void compile(Value * const self, Function * doBlockFunction);
    5353
    5454private:
     
    5656    void verifyParameter(const Var * var, const Value * param);
    5757
    58     void Examine(const PabloFunction * const function);
     58    void Examine();
    5959    void Examine(const PabloBlock * const block);
    6060
     
    7373    std::unique_ptr<CarryManager>       mCarryManager;
    7474
    75     PabloFunction *  const              mPabloFunction;
    76 
    77     PabloKernel *                       mKernelBuilder;
     75    PabloKernel * const                 mKernel;
    7876    Value *                             mSelf;
    7977
  • icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.cpp

    r5204 r5217  
    88#include <llvm/Support/Debug.h>
    99#include <pablo/pe_var.h>
    10 #include <pablo/type/streamtype.h>
    1110#include <llvm/IR/Verifier.h>
     11#include <IDISA/idisa_builder.h>
     12#include <pablo/prototype.h>
    1213
    1314using namespace pablo;
    1415using namespace kernel;
    1516using namespace parabix;
     17using namespace IDISA;
    1618
    17 PabloKernel::PabloKernel(IDISA::IDISA_Builder * builder,
    18                          std::string kernelName,
    19                          PabloFunction * function)
    20 : KernelBuilder(builder, kernelName, {}, {}, {}, {}, {Binding{builder->getBitBlockType(), "EOFbit"}, Binding{builder->getBitBlockType(), "EOFmask"}})
    21 , mPabloFunction(function)
    22 , mPabloCompiler(new PabloCompiler(this, function))
     19Var * PabloKernel::addInput(const std::string name, Type * const type) {
     20    Var * param = new Var(mSymbolTable->make(name), type);
     21    mInputs.push_back(param);
     22    if (isa<StreamType>(type)) {
     23        Type * const resolvedType = cast<StreamType>(type)->resolveType(iBuilder);
     24        mStreamSetInputs.emplace_back(resolvedType, name);
     25    } else {
     26        mScalarInputs.emplace_back(type, name);
     27    }
     28    assert (mStreamSetInputs.size() + mScalarInputs.size() == mInputs.size());
     29    return param;
     30}
    2331
    24 {
    25     for (unsigned i = 0; i < function->getNumOfParameters(); ++i) {
    26         const auto var = function->getParameter(i);
    27         Type * type = var->getType();
    28         bool scalar = false;
    29         if (isa<StreamType>(type)) {
    30             type = cast<StreamType>(type)->resolveType(builder);
    31         } else if (type->isSingleValueType()) {
    32             if (isa<IntegerType>(type) && cast<IntegerType>(type)->getBitWidth() == 0) {
    33                 type = builder->getSizeTy();
    34             }
    35             scalar = true;
    36         }
     32Var * PabloKernel::addOutput(const std::string name, Type * const type) {
     33    Var * result = new Var(mSymbolTable->make(name), type);
     34    mOutputs.push_back(result);
     35    if (isa<StreamType>(type)) {
     36        Type * const resolvedType = cast<StreamType>(type)->resolveType(iBuilder);
     37        mStreamSetOutputs.emplace_back(resolvedType, name);
     38    } else {
     39        mScalarOutputs.emplace_back(type, name);
     40    }
     41    assert (mStreamSetOutputs.size() + mScalarOutputs.size() == mOutputs.size());
     42    return result;
     43}
    3744
    38         std::string name = var->getName()->to_string();
    39         if (scalar) {
    40             mScalarInputs.emplace_back(type, std::move(name));
    41         } else {
    42             mStreamSetInputs.emplace_back(type, std::move(name));
     45Var * PabloKernel::makeVariable(PabloAST * name, Type * const type) {
     46    Var * const var = new Var(name, type);
     47    mVariables.push_back(var);
     48    return var;
     49}
     50
     51Zeroes * PabloKernel::getNullValue(Type * type) {
     52    if (type == nullptr) {
     53        type = getStreamSetTy();
     54    }
     55    for (PabloAST * constant : mConstants) {
     56        if (isa<Zeroes>(constant) && constant->getType() == type) {
     57            return cast<Zeroes>(constant);
    4358        }
    4459    }
     60    Zeroes * value = new Zeroes(type);
     61    mConstants.push_back(value);
     62    return value;
     63}
    4564
    46     for (unsigned i = 0; i < function->getNumOfResults(); ++i) {
    47         const auto var = function->getResult(i);
    48         Type * type = var->getType();
    49         bool scalar = false;
    50         if (isa<StreamType>(type)) {
    51             type = cast<StreamType>(type)->resolveType(builder);
    52         } else if (type->isSingleValueType()) {
    53             if (isa<IntegerType>(type) && cast<IntegerType>(type)->getBitWidth() == 0) {
    54                 type = builder->getSizeTy();
    55             }
    56             scalar = true;
    57         }
    58 
    59         std::string name = var->getName()->to_string();
    60         if (scalar) {
    61             mScalarOutputs.emplace_back(type, std::move(name));
    62         } else {
    63             mStreamSetOutputs.emplace_back(type, std::move(name));
     65Ones * PabloKernel::getAllOnesValue(Type * type) {
     66    if (type == nullptr) {
     67        type = getStreamSetTy();
     68    }
     69    for (PabloAST * constant : mConstants) {
     70        if (isa<Ones>(constant) && constant->getType() == type) {
     71            return cast<Ones>(constant);
    6472        }
    6573    }
    66 
    67 
    68 }
    69 
    70 PabloKernel::~PabloKernel() {
    71     delete mPabloCompiler;
     74    Ones * value = new Ones(type);
     75    mConstants.push_back(value);
     76    return value;
    7277}
    7378
     
    8287    Module * m = iBuilder->getModule();
    8388    Function * doBlockFunction = m->getFunction(mKernelName + doBlock_suffix);
    84     mPabloCompiler->compile(doBlockFunction);
    85     Function::arg_iterator args = doBlockFunction->arg_begin();
    86     Value * self = &*(args);
     89    auto args = doBlockFunction->arg_begin();
     90    Value * const self = &*(args);
     91    mPabloCompiler->compile(self, doBlockFunction);
    8792    Value * produced = getProducedItemCount(self);
    8893    produced = iBuilder->CreateAdd(produced, ConstantInt::get(iBuilder->getSizeTy(), iBuilder->getStride()));
     
    124129    iBuilder->restoreIP(savePoint);
    125130}
     131
     132PabloKernel::PabloKernel(IDISA::IDISA_Builder * builder, const std::string & kernelName)
     133: KernelBuilder(builder, kernelName, {}, {}, {}, {}, {Binding{builder->getBitBlockType(), "EOFbit"}, Binding{builder->getBitBlockType(), "EOFmask"}})
     134, mPabloCompiler(new PabloCompiler(this))
     135, mSymbolTable(new SymbolGenerator())
     136, mEntryBlock(PabloBlock::Create(this))
     137{
     138
     139}
     140
     141PabloKernel::~PabloKernel() {
     142    delete mPabloCompiler;
     143    delete mSymbolTable;
     144}
     145
  • icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.h

    r5202 r5217  
    88
    99#include <kernels/kernel.h>
    10 #include <IDISA/idisa_builder.h>
    11 #include <pablo/function.h>
     10#include <pablo/symbol_generator.h>
     11
     12namespace IDISA {
     13class IDISA_Builder;
     14}
    1215
    1316namespace pablo {
    1417   
    15 class PabloCompiler; class CarryManager;
    16 
     18class PabloCompiler;
     19class PabloBlock;
     20class PabloAST;
     21class CarryManager;
     22class Var;
     23class Zeroes;
     24class Ones;
     25class String;
     26class Integer;
    1727
    1828class PabloKernel : public kernel::KernelBuilder {
     29
     30    friend class PabloCompiler;
     31    friend class PabloBlock;
     32    friend class CarryManager;
     33
    1934public:
    20     PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName, PabloFunction * function);
     35
     36    PabloKernel(IDISA::IDISA_Builder * builder, const std::string & kernelName);
    2137    // At present only population count accumulator are supported,
    2238    // using the pablo.Count operation.
     
    2440    ~PabloKernel();
    2541
     42    PabloBlock * getEntryBlock() {
     43        return mEntryBlock;
     44    }
     45
     46    const PabloBlock * getEntryBlock() const {
     47        return mEntryBlock;
     48    }
     49
     50    PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
     51        assert (entryBlock);
     52        std::swap(mEntryBlock, entryBlock);
     53        return entryBlock;
     54    }
     55
     56    Var * getInput(const unsigned index) {
     57        return mInputs[index];
     58    }
     59
     60    const Var * getInput(const unsigned index) const {
     61        return mInputs[index];
     62    }
     63
     64    Var * addInput(const std::string name, Type * const type);
     65
     66    unsigned getNumOfInputs() const {
     67        return mInputs.size();
     68    }
     69
     70    Var * getOutput(const unsigned index) {
     71        return mOutputs[index];
     72    }
     73
     74    const Var * getOutput(const unsigned index) const {
     75        return mOutputs[index];
     76    }
     77
     78    Var * addOutput(const std::string name, Type * const type);
     79
     80    unsigned getNumOfOutputs() const {
     81        return mOutputs.size();
     82    }
     83
     84    Var * makeVariable(PabloAST * name, Type * const type);
     85
     86    Var * getVariable(const unsigned index) {
     87        return mVariables[index];
     88    }
     89
     90    unsigned getNumOfVariables() const {
     91        return mVariables.size();
     92    }
     93
     94    Zeroes * getNullValue(Type * const type);
     95
     96    Ones * getAllOnesValue(Type * const type);
     97
     98    inline SymbolGenerator * getSymbolTable() const {
     99        return mSymbolTable;
     100    }
     101
    26102protected:
     103
    27104    // A custom method for preparing kernel declarations is needed,
    28105    // so that the carry data requirements may be accommodated before
     
    36113    // This may be overridden for specialized processing.
    37114    virtual void generateFinalBlockMethod() override;
    38    
    39     PabloFunction * mPabloFunction;
    40    
    41     PabloCompiler * mPabloCompiler;
    42115
    43     friend class PabloCompiler;
    44     friend class CarryManager;
     116    inline String * getName(const std::string & name) const {
     117        return mSymbolTable->get(name);
     118    }
     119
     120    inline String * makeName(const std::string & prefix) const {
     121        return mSymbolTable->make(prefix);
     122    }
     123
     124    inline Integer * getInteger(const int64_t value) const {
     125        return mSymbolTable->getInteger(value, iBuilder);
     126    }
     127
     128private:
     129
     130    PabloCompiler * const           mPabloCompiler;
     131    SymbolGenerator *               mSymbolTable;
     132    PabloBlock *                    mEntryBlock;
     133    std::vector<Var *>              mInputs;
     134    std::vector<Var *>              mOutputs;
     135    std::vector<PabloAST *>         mConstants;
     136    std::vector<Var *>              mVariables;
     137
    45138};
     139
    46140}
     141
    47142#endif // PABLO_KERNEL_H
  • icGREP/icgrep-devel/icgrep/pablo/pablo_toolchain.cpp

    r5202 r5217  
    55 */
    66
    7 #include <string>
    8 #include <iostream>
    9 #include <fstream>
    10 
    117#include <pablo/pablo_toolchain.h>
     8#include <pablo/pablo_kernel.h>
    129#include <pablo/pablo_compiler.h>
    1310#include <pablo/optimizers/pablo_simplifier.hpp>
     
    2320#include <pablo/optimizers/schedulingprepass.h>
    2421#endif
    25 #include <pablo/function.h>
     22#include <pablo/prototype.h>
    2623#include <pablo/analysis/pabloverifier.hpp>
    2724#include <pablo/printer_pablos.h>
    28 #include <sstream>
    2925#include <llvm/Support/CommandLine.h>
    3026#include <llvm/Support/FileSystem.h>
     
    3228#include <hrtime.h>
    3329#endif
     30#include <string>
     31#include <iostream>
     32#include <fstream>
     33#include <sstream>
    3434
    3535namespace pablo {
     
    172172#endif
    173173
    174 void pablo_function_passes(PabloFunction * function) {
     174void pablo_function_passes(PabloKernel * kernel) {
    175175   
    176176    if (DebugOptions.isSet(PrintCompiledREcode)) {
     
    178178        llvm::raw_os_ostream cerr(std::cerr);
    179179        cerr << "Initial Pablo AST:\n";
    180         PabloPrinter::print(*function, cerr);
     180        PabloPrinter::print(kernel, cerr);
    181181    }
    182182   
    183183    #ifndef NDEBUG
    184     PabloVerifier::verify(*function, "creation");
     184    PabloVerifier::verify(kernel, "creation");
    185185    #endif
    186186
     
    202202    if (!PabloOptimizationsOptions.isSet(DisableSimplification)) {
    203203        READ_CYCLE_COUNTER(simplification_start);
    204         Simplifier::optimize(*function);
     204        Simplifier::optimize(kernel);
    205205        READ_CYCLE_COUNTER(simplification_end);
    206206    }
    207207    if (Flatten){
    208208        READ_CYCLE_COUNTER(flattenif_start);
    209         FlattenIf::transform(*function);
     209        FlattenIf::transform(kernel);
    210210        READ_CYCLE_COUNTER(flattenif_end);
    211211    }
     
    213213//    if (PabloOptimizationsOptions.isSet(EnableLowering) || PabloOptimizationsOptions.isSet(EnablePreDistribution) || PabloOptimizationsOptions.isSet(EnablePostDistribution)) {
    214214//        READ_CYCLE_COUNTER(coalescing_start);
    215 //        CanonicalizeDFG::transform(*function);
     215//        CanonicalizeDFG::transform(kernel);
    216216//        READ_CYCLE_COUNTER(coalescing_end);
    217217//    }
    218218    if (PabloOptimizationsOptions.isSet(EnablePreDistribution)) {
    219219        READ_CYCLE_COUNTER(pre_distribution_start);
    220         BooleanReassociationPass::optimize(*function);
     220        BooleanReassociationPass::optimize(kernel);
    221221        READ_CYCLE_COUNTER(pre_distribution_end);
    222222    }
    223223    if (PabloOptimizationsOptions.isSet(EnableMultiplexing)) {
    224224        READ_CYCLE_COUNTER(multiplexing_start);
    225         MultiplexingPass::optimize(*function);
     225        MultiplexingPass::optimize(kernel);
    226226        READ_CYCLE_COUNTER(multiplexing_end);
    227227//        if (PabloOptimizationsOptions.isSet(EnableLowering) || PabloOptimizationsOptions.isSet(EnablePreDistribution) || PabloOptimizationsOptions.isSet(EnablePostDistribution)) {
    228 //            CanonicalizeDFG::transform(*function);
     228//            CanonicalizeDFG::transform(kernel);
    229229//        }
    230230    }
    231231    if (PabloOptimizationsOptions.isSet(EnablePostDistribution)) {
    232232        READ_CYCLE_COUNTER(post_distribution_start);
    233         BooleanReassociationPass::optimize(*function);
     233        BooleanReassociationPass::optimize(kernel);
    234234        READ_CYCLE_COUNTER(post_distribution_end);
    235235    }
     
    237237    if (PabloOptimizationsOptions.isSet(EnableCodeMotion)) {
    238238        READ_CYCLE_COUNTER(sinking_start);
    239         CodeMotionPass::optimize(*function);
     239        CodeMotionPass::optimize(kernel);
    240240        READ_CYCLE_COUNTER(sinking_end);
    241241    }
     
    245245        llvm::raw_os_ostream cerr(std::cerr);
    246246        cerr << "Unlowered Pablo AST:\n";
    247         PabloPrinter::print(*function, cerr);
     247        PabloPrinter::print(kernel, cerr);
    248248    }
    249249    #ifdef PRINT_TIMING_INFORMATION
     
    252252//    if (PabloOptimizationsOptions.isSet(EnableLowering) || PabloOptimizationsOptions.isSet(EnablePreDistribution) || PabloOptimizationsOptions.isSet(EnablePostDistribution)) {
    253253//        READ_CYCLE_COUNTER(lowering_start);
    254 //        FactorizeDFG::transform(*function);
     254//        FactorizeDFG::transform(kernel);
    255255//        READ_CYCLE_COUNTER(lowering_end);
    256256//    }
    257257//    if (PabloOptimizationsOptions.isSet(EnablePrePassScheduling)) {
    258258//        READ_CYCLE_COUNTER(scheduling_start);
    259 //        SchedulingPrePass::optimize(*function);
     259//        SchedulingPrePass::optimize(kernel);
    260260//        READ_CYCLE_COUNTER(scheduling_end);
    261261//    }
     
    269269            llvm::raw_os_ostream cerr(std::cerr);
    270270            cerr << "Final Pablo AST:\n";
    271             PabloPrinter::print(*function, cerr);
     271            PabloPrinter::print(kernel, cerr);
    272272        } else {
    273273            std::error_code error;
    274274            llvm::raw_fd_ostream out(PabloOutputFilename, error, sys::fs::OpenFlags::F_None);
    275             PabloPrinter::print(*function, out);
     275            PabloPrinter::print(kernel, out);
    276276        }
    277277    }
  • icGREP/icgrep-devel/icgrep/pablo/pablo_toolchain.h

    r5202 r5217  
    88#define PABLO_TOOLCHAIN_H
    99
    10 #include <pablo/function.h>
    11 #include <llvm/Support/CommandLine.h>
     10namespace llvm {
     11namespace cl {
     12class OptionCategory;
     13}
     14}
    1215
    1316namespace pablo {
    14    
     17
     18class PabloKernel;
     19
    1520enum PabloDebugFlags {
    1621    PrintOptimizedREcode, PrintCompiledCCcode, PrintCompiledREcode, DumpTrace, PrintUnloweredCode
     
    2227};
    2328   
    24 const cl::OptionCategory * pablo_toolchain_flags();
     29const llvm::cl::OptionCategory * pablo_toolchain_flags();
    2530
    2631bool DebugOptionIsSet(PabloDebugFlags flag);
    2732
    28 void pablo_function_passes(PabloFunction * function);
     33void pablo_function_passes(PabloKernel * kernel);
    2934
    3035}
  • icGREP/icgrep-devel/icgrep/pablo/passes/flattenif.cpp

    r5202 r5217  
    11#include <pablo/passes/flattenif.hpp>
     2#include <pablo/pablo_kernel.h>
    23#include <pablo/codegenstate.h>
    34#include <pablo/analysis/pabloverifier.hpp>
     
    3132 * @brief transform
    3233 ** ------------------------------------------------------------------------------------------------------------- */
    33 void FlattenIf::transform(PabloFunction & function) {
    34     flattenIf(function.getEntryBlock());
     34void FlattenIf::transform(PabloKernel * function) {
     35    flattenIf(function->getEntryBlock());
    3536    #ifndef NDEBUG
    3637    PabloVerifier::verify(function, "flatten-if");
  • icGREP/icgrep-devel/icgrep/pablo/passes/flattenif.hpp

    r5202 r5217  
    44namespace pablo {
    55
    6 class PabloFunction;
     6class PabloKernel;
    77class PabloBlock;
    88
    99class FlattenIf {
    1010public:
    11     static void transform(PabloFunction & function);
     11    static void transform(PabloKernel * function);
    1212protected:
    1313    FlattenIf() = default;
  • icGREP/icgrep-devel/icgrep/pablo/pe_advance.h

    r5202 r5217  
    2828        return getOperand(0);
    2929    }
    30     inline Integer::Type getAmount() const {
     30    inline int64_t getAmount() const {
    3131        return cast<Integer>(getOperand(1))->value();
    3232    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r5202 r5217  
    33
    44#include <pablo/pabloAST.h>
    5 #include <pablo/function.h>
     5#include <pablo/prototype.h>
    66
    77namespace pablo {
  • icGREP/icgrep-devel/icgrep/pablo/pe_count.h

    r5204 r5217  
    2727    }
    2828protected:
    29     explicit Count(PabloAST * expr, const String * counter)
    30         : Statement(ClassTypeId::Count, getScalarTy(), {expr}, counter)
    31     {
     29    explicit Count(PabloAST * expr, const String * counter, Type * type)
     30    : Statement(ClassTypeId::Count, type, {expr}, counter) {
    3231
    3332    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_integer.h

    r5204 r5217  
    99    friend class SymbolGenerator;
    1010public:
    11     typedef u_int64_t Type;
     11
     12
    1213    static inline bool classof(const PabloAST * e) {
    1314        return e->getClassTypeId() == ClassTypeId::Integer;
     
    1920
    2021    }
    21     inline Type value() const {
     22    inline int64_t value() const {
    2223        return mValue;
    2324    }
    2425protected:
    25     Integer(Type value) noexcept
    26     : PabloAST(ClassTypeId::Integer, getScalarTy(), nullptr)
     26    Integer(const int64_t value, Type * type) noexcept
     27    : PabloAST(ClassTypeId::Integer, type, nullptr)
    2728    , mValue(value)
    2829    {
     
    3031    }
    3132private:
    32     Type mValue;
     33    int64_t mValue;
    3334};
    3435
  • icGREP/icgrep-devel/icgrep/pablo/pe_lookahead.h

    r5202 r5217  
    2828        return getOperand(0);
    2929    }
    30     inline Integer::Type getAmount() const {
     30    inline int64_t getAmount() const {
    3131        return cast<Integer>(getOperand(1))->value();
    3232    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_ones.h

    r5202 r5217  
    1414class Ones : public PabloAST {
    1515    friend class PabloBlock;
    16     friend class PabloFunction;
     16    friend class PabloKernel;
    1717public:
    1818    static inline bool classof(const PabloAST * e) {
  • icGREP/icgrep-devel/icgrep/pablo/pe_setithbit.h

    r5202 r5217  
    1919        return getOperand(0);
    2020    }
    21     inline Integer::Type position() const {
     21    inline int64_t pint64_tion() const {
    2222        return cast<Integer>(getOperand(1))->value();
    2323    }
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r5202 r5217  
    2323    friend class PabloBlock;
    2424    friend class PabloAST;
    25     friend class PabloFunction;
     25    friend class PabloKernel;
    2626    friend class Statement;
    2727public:
     
    5353        return getOperand(0);
    5454    }
    55     inline Integer * getIndex() const {
    56         return cast<Integer>(getOperand(1));
     55    inline PabloAST * getIndex() const {
     56        return getOperand(1);
    5757    }
    5858protected:
    59     Extract(PabloAST * array, PabloAST * const index, const String * const name)
    60     : Statement(ClassTypeId::Extract, cast<ArrayType>(array->getType())->getArrayElementType(), {array, cast<Integer>(index)}, name) {
     59    Extract(PabloAST * array, PabloAST * const index, const String * const name, Type * type)
     60    : Statement(ClassTypeId::Extract, type, {array, index}, name) {
    6161
    6262    }
    6363};
    64 
    65 //class Extract : public PabloAST {
    66 //    friend class PabloBlock;
    67 //public:
    68 //    static inline bool classof(const PabloAST * e) {
    69 //        return e->getClassTypeId() == ClassTypeId::Extract;
    70 //    }
    71 //    static inline bool classof(const void *) {
    72 //        return false;
    73 //    }
    74 //    virtual ~Extract(){
    75 //    }
    76 //    inline const String * getName() const {
    77 //        if (isa<Parameter>(mArray)) {
    78 //            return cast<Parameter>(mArray)->getName();
    79 //        } else {
    80 //            return cast<Statement>(mArray)->getName();
    81 //        }
    82 //    }
    83 //    inline const PabloAST * getArray() const {
    84 //        return mArray;
    85 //    }
    86 //    inline const Integer * getIndex() const {
    87 //        return mIndex;
    88 //    }
    89 //protected:
    90 //    Extract(PabloAST * array, PabloAST * const index)
    91 //    : PabloAST(ClassTypeId::Extract, array->getType()->getIndexedType())
    92 //    , mArray(array)
    93 //    , mIndex(cast<Integer>(index)) {
    94 //        assert (isa<Parameter>(array) || isa<Statement>(array));
    95 //    }
    96 //private:
    97 //    PabloAST * mArray;
    98 //    Integer * mIndex;
    99 //};
    100 
    101 //class ParameterBinding {
    102 //    using Allocator = SlabAllocator<Parameter *>;
    103 
    104 //public:
    105 
    106 //    void add(Parameter * const param);
    107 
    108 //private:
    109 //    std::vector<Parameter *, Allocator> mParameters;
    110 //};
    111 
    11264
    11365}
  • icGREP/icgrep-devel/icgrep/pablo/pe_zeroes.h

    r5202 r5217  
    1515class Zeroes : public PabloAST {
    1616    friend class PabloBlock;
    17     friend class PabloFunction;
     17    friend class PabloKernel;
    1818public:
    1919    static inline bool classof(const PabloAST * expr) {
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.cpp

    r5202 r5217  
    77#include "printer_pablos.h"
    88#include <pablo/codegenstate.h>
     9#include <pablo/pablo_kernel.h>
    910#include <llvm/Support/raw_os_ostream.h>
    10 #include <iostream>
    1111
    1212using namespace pablo;
     
    1616const unsigned BlockIndenting = 2;
    1717
    18 void PabloPrinter::print(const PabloFunction & function, llvm::raw_ostream & out) {
    19     print(function.getEntryBlock(), out, true);
     18void PabloPrinter::print(const PabloKernel * kernel, llvm::raw_ostream & out) {
     19    print(kernel->getEntryBlock(), out, true);
    2020}
    2121
     
    146146    } else if (isa<Prototype>(expr)) {
    147147        out << cast<Prototype>(expr)->getName();
    148     } else if (isa<PabloFunction>(expr)) {
    149         out << cast<PabloFunction>(expr)->getName();
    150148    } else {
    151149        out << "???";
  • icGREP/icgrep-devel/icgrep/pablo/printer_pablos.h

    r5202 r5217  
    1212namespace pablo {
    1313
    14 class PabloFunction;
     14class PabloKernel;
    1515class PabloBlock;
    1616class Statement;
     
    1919class PabloPrinter {
    2020public:
    21     static void print(const PabloFunction & function, llvm::raw_ostream & out);
     21    static void print(const PabloKernel * kernel, llvm::raw_ostream & out);
    2222    static void print(const PabloAST * expr, llvm::raw_ostream & out);
    2323    static void print(const PabloBlock * block, llvm::raw_ostream & strm, const bool expandNested = false, const unsigned indent = 0);
  • icGREP/icgrep-devel/icgrep/pablo/prototype.cpp

    r5216 r5217  
    1 #include "function.h"
     1#include "prototype.h"
    22#include <pablo/codegenstate.h>
    33#include <cstring>
     
    1313}
    1414
    15 PabloFunction::PabloFunction(std::string && name)
    16 : Prototype(ClassTypeId::Function, std::move(name), 0, 0)
    17 , mSymbolTable(new SymbolGenerator())
    18 , mEntryBlock(PabloBlock::Create(*this))
    19 , mConstants(0, nullptr) {
    20 
    2115}
    22 
    23 Var * PabloFunction::addParameter(const std::string name, Type * const type) {
    24     Var * param = new Var(mSymbolTable->make(name), type);
    25     mParameters.push_back(param);
    26     mNumOfParameters = mParameters.size();
    27     return param;
    28 }
    29 
    30 Var * PabloFunction::addResult(const std::string name, Type * const type) {
    31     Var * result = new Var(mSymbolTable->make(name), type);
    32     mResults.push_back(result);
    33     mNumOfResults = mResults.size();
    34     return result;
    35 }
    36 
    37 Var * PabloFunction::makeVariable(PabloAST * name, Type * const type) {
    38     Var * const var = new Var(name, type);
    39     mVariables.push_back(var);
    40     return var;
    41 }
    42 
    43 Zeroes * PabloFunction::getNullValue(Type * type) {
    44     if (type == nullptr) {
    45         type = getStreamTy();
    46     }
    47     for (PabloAST * constant : mConstants) {
    48         if (isa<Zeroes>(constant) && constant->getType() == type) {
    49             return cast<Zeroes>(constant);
    50         }
    51     }
    52     Zeroes * value = new Zeroes(type);
    53     mConstants.push_back(value);
    54     return value;
    55 }
    56 
    57 Ones * PabloFunction::getAllOnesValue(Type * type) {
    58     if (type == nullptr) {
    59         type = getStreamTy();
    60     }
    61     for (PabloAST * constant : mConstants) {
    62         if (isa<Ones>(constant) && constant->getType() == type) {
    63             return cast<Ones>(constant);
    64         }
    65     }
    66     Ones * value = new Ones(type);
    67     mConstants.push_back(value);
    68     return value;
    69 }
    70 
    71 void PabloFunction::throwInvalidParameterIndex(const unsigned index) const {
    72     throw std::runtime_error(
    73                 "Invalid parameter index " +
    74                 std::to_string(index) + " of " + std::to_string(getNumOfParameters()) +
    75                 " in function " + getName()->to_string());
    76 }
    77 
    78 void PabloFunction::throwInvalidResultIndex(const unsigned index) const {
    79     throw std::runtime_error(
    80                 "Invalid result index " +
    81                 std::to_string(index) + " of " + std::to_string(getNumOfResults()) +
    82                 " in function " + getName()->to_string());
    83 }
    84 
    85 void PabloFunction::operator delete(void * ptr) {
    86     PabloFunction * f = static_cast<PabloFunction *>(ptr);
    87     delete f->mSymbolTable;
    88     f->mSymbolTable = nullptr;
    89 }
    90 
    91 }
  • icGREP/icgrep-devel/icgrep/pablo/prototype.h

    r5216 r5217  
    5050}
    5151
    52 class PabloFunction : public Prototype {
    53     friend class PabloBlock;
    54     friend class Branch;
    55     using Allocator = SlabAllocator<PabloAST *>;
    56 public:
    57 
    58     static inline bool classof(const PabloAST * e) {
    59         switch (e->getClassTypeId()) {
    60             case ClassTypeId::Function:
    61             case ClassTypeId::Prototype:
    62                 return true;
    63             default:
    64                 return false;
    65         }       
    66     }
    67 
    68     static inline bool classof(void *) {
    69         return false;
    70     }
    71 
    72     static PabloFunction * Create(std::string name);
    73    
    74     virtual bool operator==(const PabloAST & other) const {
    75         return &other == this;
    76     }
    77 
    78     PabloBlock * getEntryBlock() {
    79         return mEntryBlock;
    80     }
    81 
    82     const PabloBlock * getEntryBlock() const {
    83         return mEntryBlock;
    84     }
    85 
    86     PabloBlock * setEntryBlock(PabloBlock * entryBlock) {
    87         assert (entryBlock);
    88         std::swap(mEntryBlock, entryBlock);
    89         return entryBlock;
    90     }
    91 
    92     Var * getParameter(const unsigned index) {
    93         return static_cast<Var *>(mParameters[index]);
    94     }
    95 
    96     const Var * getParameter(const unsigned index) const {
    97         return static_cast<Var *>(mParameters[index]);
    98     }
    99 
    100     Var * addParameter(const std::string name, Type * const type);
    101 
    102     Var * getResult(const unsigned index) {
    103         return static_cast<Var *>(mResults[index]);
    104     }
    105 
    106     const Var * getResult(const unsigned index) const {
    107         return static_cast<Var *>(mResults[index]);
    108     }
    109 
    110     Var * addResult(const std::string name, Type * const type);
    111 
    112     Var * makeVariable(PabloAST * name, Type * const type);
    113 
    114     Var * getVariable(const unsigned index) {
    115         return static_cast<Var *>(mVariables[index]);
    116     }
    117 
    118     unsigned getNumOfVariables() {
    119         return mVariables.size();
    120     }
    121 
    122     Zeroes * getNullValue(Type * const type);
    123 
    124     Ones * getAllOnesValue(Type * const type);
    125 
    126     void operator delete (void*);
    127 
    128     virtual ~PabloFunction() { }
    129 
    130     inline SymbolGenerator * getSymbolTable() const {
    131         return mSymbolTable;
    132     }
    133 
    134 protected:
    135 
    136     __attribute__((noreturn)) void throwInvalidParameterIndex(const unsigned index) const;
    137 
    138     __attribute__((noreturn)) void throwInvalidResultIndex(const unsigned index) const;
    139 
    140     PabloFunction(std::string && name);
    141 private:
    142     SymbolGenerator *                           mSymbolTable;
    143     PabloBlock *                                mEntryBlock;
    144     std::vector<PabloAST *, Allocator>          mParameters;
    145     std::vector<PabloAST *, Allocator>          mResults;
    146     std::vector<PabloAST *, Allocator>          mConstants;
    147     std::vector<PabloAST *, Allocator>          mVariables;
    148 };
    149 
    150 inline PabloFunction * PabloFunction::Create(std::string name) {
    151     return new PabloFunction(std::move(name));
    152 }
    153    
    15452}
    15553
  • icGREP/icgrep-devel/icgrep/pablo/symbol_generator.cpp

    r5202 r5217  
    88#include <pablo/pe_string.h>
    99#include <pablo/pe_integer.h>
     10#include <IDISA/idisa_builder.h>
    1011
    1112namespace pablo {
     
    2829}
    2930
    30 Integer * SymbolGenerator::getInteger(const integer_t value) {
     31Integer * SymbolGenerator::getInteger(const integer_t value, IDISA::IDISA_Builder * builder) {
    3132    auto f = mIntegerMap.find(value);
    3233    Integer * result;
    3334    if (f == mIntegerMap.end()) {
    34         result = new Integer(value);
     35        result = new Integer(value, builder->getSizeTy());
    3536        assert (result->value() == value);
    3637        mIntegerMap.insert(std::make_pair(value, result));
  • icGREP/icgrep-devel/icgrep/pablo/symbol_generator.h

    r5202 r5217  
    99
    1010#include <pablo/pabloAST.h>
     11#include <unordered_map>
    1112#include <string>
    12 #include <unordered_map>
    13 #include <llvm/ADT/Twine.h>
    14 #include <llvm/ADT/StringMap.h>
    15 #include <llvm/Support/StringPool.h>
     13
     14namespace IDISA {
     15    class IDISA_Builder;
     16}
    1617
    1718namespace pablo {
     
    2425    using Twine = llvm::Twine;
    2526public:
    26     typedef u_int64_t integer_t;
     27    typedef int64_t integer_t;
    2728    String * get(const std::string name);
    2829    String * make(const std::string prefix);
    29     Integer * getInteger(const integer_t value);
     30    Integer * getInteger(const integer_t value, IDISA::IDISA_Builder * builder);
    3031    SymbolGenerator() = default;
    3132    ~SymbolGenerator() = default;
     
    3637};
    3738
    38 static SymbolGenerator GlobalSymbolGenerator;
    39 
    4039}
    4140
Note: See TracChangeset for help on using the changeset viewer.