Ignore:
Timestamp:
Jan 10, 2015, 3:14:51 PM (4 years ago)
Author:
nmedfort
Message:

More work on usedef info.

File:
1 edited

Legend:

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

    r4414 r4415  
    66
    77#include <pablo/codegenstate.h>
    8 #include <iostream>
    98
    109namespace pablo {
     
    1615        return expr;
    1716    }
    18     return appendIfNew(mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount, mSymbolGenerator, this));
     17    return insertIfNew(mUnaryWithInt.findOrMake<Advance>(PabloAST::ClassTypeId::Advance, expr, shiftAmount, mSymbolGenerator, this));
     18}
     19
     20Assign * PabloBlock::createImmutableAssign(const std::string prefix, PabloAST * expr, const int outputIndex) {
     21    return insertIfNew(mUnary.findOrMake<Assign>(PabloAST::ClassTypeId::Assign, expr, outputIndex, mSymbolGenerator->make(prefix), this));
    1922}
    2023
    2124Call * PabloBlock::createCall(const std::string name) {
    22     return appendIfNew(mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, mSymbolGenerator->get(name), this));
     25    return createCall(mSymbolGenerator->get(name));
     26}
     27
     28Call * PabloBlock::createCall(String * name) {
     29    return insertIfNew(mUnary.findOrMake<Call>(PabloAST::ClassTypeId::Call, name, this));
    2330}
    2431
     
    2835
    2936Not * PabloBlock::createNotImm(PabloAST * expr) {
    30     return appendIfNew(mUnary.findOrMake<Not>(PabloAST::ClassTypeId::Not, expr, this));
     37    return insertIfNew(mUnary.findOrMake<Not>(PabloAST::ClassTypeId::Not, expr, this));
    3138}
    3239
     40Var * PabloBlock::createVar(const std::string name) {
     41    return createVar(mSymbolGenerator->get(name));
     42}
    3343
    34 Var * PabloBlock::createVar(const std::string name) {
    35     return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, mSymbolGenerator->get(name), this).first;
     44Var * PabloBlock::createVar(String * name) {
     45    return mUnary.findOrMake<Var>(PabloAST::ClassTypeId::Var, name, this).first;
    3646}
    3747
     
    3949
    4050Next * PabloBlock::createNext(Assign * assign, PabloAST * expr) {
    41     return appendIfNew(mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, this));
     51    return insertIfNew(mBinary.findOrMake<Next>(PabloAST::ClassTypeId::Next, assign, expr, this));
    4252}
    4353
     
    4656        return marker;
    4757    }
    48     return appendIfNew(mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass, mSymbolGenerator, this));
     58    return insertIfNew(mBinary.findOrMake<MatchStar>(PabloAST::ClassTypeId::MatchStar, marker, charclass, mSymbolGenerator, this));
    4959}
    5060
     
    5363        return from;
    5464    }
    55     return appendIfNew(mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru, mSymbolGenerator, this));
     65    return insertIfNew(mBinary.findOrMake<ScanThru>(PabloAST::ClassTypeId::ScanThru, from, thru, mSymbolGenerator, this));
    5666}
    5767
     
    6474
    6575And * PabloBlock::createAndImm(PabloAST * expr1, PabloAST * expr2) {
    66     return appendIfNew(mBinary.findOrMake<And>(PabloAST::ClassTypeId::And, expr1, expr2, this));
     76    return insertIfNew(mBinary.findOrMake<And>(PabloAST::ClassTypeId::And, expr1, expr2, this));
    6777}
    6878
     
    7585
    7686Or * PabloBlock::createOrImm(PabloAST * expr1, PabloAST * expr2) {
    77     return appendIfNew(mBinary.findOrMake<Or>(PabloAST::ClassTypeId::Or, expr1, expr2, this));
     87    return insertIfNew(mBinary.findOrMake<Or>(PabloAST::ClassTypeId::Or, expr1, expr2, this));
    7888}
    7989
     
    8696
    8797Xor * PabloBlock::createXorImm(PabloAST * expr1, PabloAST * expr2) {
    88     return appendIfNew(mBinary.findOrMake<Xor>(PabloAST::ClassTypeId::Xor, expr1, expr2,  this));
     98    return insertIfNew(mBinary.findOrMake<Xor>(PabloAST::ClassTypeId::Xor, expr1, expr2,  this));
    8999}
    90100
     
    96106
    97107Sel * PabloBlock::createSelImm(PabloAST * condition, PabloAST * trueExpr, PabloAST * falseExpr) {
    98     return appendIfNew(mTernary.findOrMake<Sel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this));
     108    return insertIfNew(mTernary.findOrMake<Sel>(PabloAST::ClassTypeId::Sel, condition, trueExpr, falseExpr, this));
    99109}
    100110
    101 //PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
     111PabloAST * PabloBlock::setOperandOf(Statement * inst, const unsigned index, PabloAST * value) {
    102112
     113    assert (index < inst->getNumOperands() && inst->getOperand(index) != value);
    103114
     115    // get the current insertion point so we can restore it later
     116    Statement * const ip = getInsertPoint();
     117    const bool replacingCurrentIP = (ip == inst);
    104118
     119    // set the current ip to the position of the inst we're "updating"
     120    setInsertPoint(inst);
     121    // this will move the ip back to inst's prior node
     122    inst->removeFromParent();
    105123
    106 //}
     124    PabloAST * retVal = inst;
    107125
    108 //PabloAST * PabloBlock::replaceUsesOfWith(PabloAST * inst, PabloAST * from, PabloAST * to) {
    109 //    if (from == to) {
    110 //        return inst;
    111 //    }
    112 //    switch (inst->getClassTypeId()) {
    113 //        case PabloAST::ClassTypeId::Advance:
    114 //            {
    115 //                Advance * n = cast<Advance>(inst);
    116 //                if (n->getExpr() == from) {
    117 //                    return createAdvance(to, n->getAdvanceAmount());
    118 //                }
    119 //                return inst;
    120 //            }
     126    switch (inst->getClassTypeId()) {
     127        case PabloAST::ClassTypeId::Advance:
     128            retVal = createAdvance(value, cast<Advance>(inst)->getAdvanceAmount());
     129            break;
     130        case PabloAST::ClassTypeId::Not:
     131            retVal = createNot(value);
     132            break;
    121133//        case PabloAST::ClassTypeId::Assign:
    122 //            {
    123 //                Assign * n = cast<Assign>(inst);
    124 //                if (n->getExpr() == from) {
    125 //                    Assign * assign = createAssign(to);
    126 //                    n->replaceWith(assign);
    127 //                    return assign;
    128 //                }
    129 //                return inst;
    130 //            }
    131 //        case PabloAST::ClassTypeId::Var:
    132 //            {
    133 //                Var * n = cast<Var>(inst);
    134 //                if (n->getVar() == from) {
    135 //                    return createVar(to);
    136 //                }
    137 //                return inst;
    138 //            }
    139 //        case PabloAST::ClassTypeId::Next:
    140 //            {
    141 //                Next * n = cast<Next>(inst);
    142 //                if (n->getInitial() == from || n->getExpr() == from) {
    143 //                    return createNext(n->getInitial() == from ? to : n->getInitial(),
    144 //                                      n->getExpr() == from ? to : n->getExpr());
    145 //                }
    146 //                return inst;
    147 //            }
    148 ////        case PabloAST::ClassTypeId::Call:
    149 ////            {
    150 ////                Call * n = cast<Call>(node);
    151 ////                if (n->getCallee() == from) {
    152 ////                    return createCall(to, n->getExpr());
    153 ////                }
    154 ////                return node;
    155 ////            }
    156 //        case PabloAST::ClassTypeId::Not:
    157 //            {
    158 //                Not * n = cast<Not>(inst);
    159 //                if (n->getExpr() == from) {
    160 //                    return createNot(to);
    161 //                }
    162 //                return inst;
    163 //            }
    164 //        case PabloAST::ClassTypeId::And:
    165 //            {
    166 //                And * n = cast<And>(inst);
    167 //                if (n->getExpr1() == from || n->getExpr2() == from) {
    168 //                    return createAnd(n->getExpr1() == from ? to : n->getExpr1(),
    169 //                                     n->getExpr2() == from ? to : n->getExpr2());
    170 //                }
    171 //                return inst;
    172 //            }
    173 //        case PabloAST::ClassTypeId::Or:
    174 //            {
    175 //                Or * n = cast<Or>(inst);
    176 //                if (n->getExpr1() == from || n->getExpr2() == from) {
    177 //                    return createOr(n->getExpr1() == from ? to : n->getExpr1(),
    178 //                                    n->getExpr2() == from ? to : n->getExpr2());
    179 //                }
    180 //                return inst;
    181 //            }
    182 //        case PabloAST::ClassTypeId::Xor:
    183 //            {
    184 //                Xor * n = cast<Xor>(inst);
    185 //                if (n->getExpr1() == from || n->getExpr2() == from) {
    186 //                    return createXor(n->getExpr1() == from ? to : n->getExpr1(),
    187 //                                     n->getExpr2() == from ? to : n->getExpr2());
    188 //                }
    189 //                return inst;
    190 //            }
    191 //        case PabloAST::ClassTypeId::ScanThru:
    192 //            {
    193 //                ScanThru * n = cast<ScanThru>(inst);
    194 //                if (n->getScanFrom() == from || n->getScanThru() == from) {
    195 //                    return createScanThru(n->getScanFrom() == from ? to : n->getScanFrom(),
    196 //                                          n->getScanThru() == from ? to : n->getScanThru());
    197 //                }
    198 //                return inst;
    199 //            }
    200 //        case PabloAST::ClassTypeId::MatchStar:
    201 //            {
    202 //                MatchStar * n = cast<MatchStar>(inst);
    203 //                if (n->getMarker() == from || n->getScanThru() == from) {
    204 //                    return createMatchStar(n->getMarker() == from ? to : n->getMarker(),
    205 //                                           n->getScanThru() == from ? to : n->getScanThru());
    206 //                }
    207 //                return inst;
    208 //            }
    209 //        case PabloAST::ClassTypeId::Ones:
    210 //        case PabloAST::ClassTypeId::Zeroes:
    211 //        case PabloAST::ClassTypeId::If:
    212 //        case PabloAST::ClassTypeId::While:
    213 //            return inst;
    214 //        default:
    215 //            throw std::runtime_error("Unhandled node type (" + std::to_string(inst->getClassTypeId()) +
    216 //                                     ") given to PabloBlock::replaceUsesOfWith(...)")
    217 //    }
     134//            retVal = createAssign(value, cast<Assign>(inst)->getOutputIndex());
     135//            break;
     136        case PabloAST::ClassTypeId::Var:
     137            retVal = createVar(cast<String>(value));
     138            break;
     139        case PabloAST::ClassTypeId::Call:
     140            retVal = createCall(cast<String>(value));
     141            break;
     142        case PabloAST::ClassTypeId::And:
     143            retVal = createAnd(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     144            break;
     145        case PabloAST::ClassTypeId::Or:
     146            retVal = createOr(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     147            break;
     148        case PabloAST::ClassTypeId::Xor:
     149            retVal = createXor(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     150            break;
     151        case PabloAST::ClassTypeId::Next:
     152            retVal = createNext(cast<Assign>(index == 0 ? value : inst->getOperand(0)), index == 1 ? value : inst->getOperand(1));
     153            break;
     154        case PabloAST::ClassTypeId::ScanThru:
     155            retVal = createScanThru(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     156            break;
     157        case PabloAST::ClassTypeId::MatchStar:
     158            retVal = createMatchStar(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1));
     159            break;
     160        case PabloAST::ClassTypeId::Sel:
     161            retVal = createSel(index == 0 ? value : inst->getOperand(0), index == 1 ? value : inst->getOperand(1), index == 2 ? value : inst->getOperand(2));
     162            break;
     163        default:
     164            break;
     165    }
    218166
    219 //}
     167    // restore our insertion point
     168    setInsertPoint(replacingCurrentIP ? inst : ip);
    220169
     170    return retVal;
     171}
    221172
    222173}
Note: See TracChangeset for help on using the changeset viewer.