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

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

File:
1 edited

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()) {
Note: See TracChangeset for help on using the changeset viewer.