libpcp/pcp_visitor.cc

   1 // Copyright (C) 2009 Free Software Foundation, Inc.
   2 // Contributed by Jan Sjodin <jan.sjodin@amd.com>.
   3
   4 // This file is part of the Polyhedral Compilation Package Library (libpcp).
   5
   6 // Libpcp is free software; you can redistribute it and/or modify it
   7 // under the terms of the GNU Lesser General Public License as published by
   8 // the Free Software Foundation; either version 2.1 of the License, or
   9 // (at your option) any later version.
  10
  11 // Libpcp is distributed in the hope that it will be useful, but WITHOUT ANY
  12 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13 // FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
  14 // more details.
  15
  16 // You should have received a copy of the GNU Lesser General Public License
  17 // along with libpcp; see the file COPYING.LIB.  If not, write to the
  18 // Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19 // MA 02110-1301, USA.
  20
  21 // As a special exception, if you link this library with other files, some
  22 // of which are compiled with GCC, to produce an executable, this library
  23 // does not by itself cause the resulting executable to be covered by the
  24 // GNU General Public License.  This exception does not however invalidate
  25 // any other reasons why the executable file might be covered by the GNU
  26 // General Public License.
  27
  28 #include "pcp.h"
  29 #include "pcp_visitor.h"
  30
  31 void
  32 PcpVisitor::visitChildren(PcpArrayType* arrayType)
  33 {
  34   PcpIterator<PcpExpr*>* iter = arrayType->getDimensionsIterator();
  35   for(;iter->hasNext(); iter->next())
  36     {
  37       iter->get()->accept(this);
  38     }
  39   delete iter;
  40 }
  41
  42 void
  43 PcpVisitor::visitChildren(PcpArith* arith)
  44 {
  45   PcpIterator<PcpExpr*>* iter = arith->getOperandsIterator();
  46   for(;iter->hasNext(); iter->next())
  47     {
  48       iter->get()->accept(this);
  49     }
  50   delete iter;
  51 }
  52
  53 void
  54 PcpVisitor::visitChildren(PcpArrayAccess* arrayAccess)
  55 {
  56   PcpIterator<PcpExpr*>* iter = arrayAccess->getSubscriptsIterator();
  57   for(;iter->hasNext(); iter->next())
  58     {
  59       iter->get()->accept(this);
  60     }
  61   delete iter;
  62 }
  63
  64 void
  65 PcpVisitor::visitChildren(PcpCopy* copy)
  66 {
  67   copy->getDest()->accept(this);
  68   copy->getSrc()->accept(this);
  69 }
  70
  71 void
  72 PcpVisitor::visitChildren(PcpUserStmt* userStmt)
  73 {
  74   PcpIterator<PcpArrayAccess*>* iter = userStmt->getArrayAccessesIterator();
  75   for(;iter->hasNext(); iter->next())
  76     {
  77       iter->get()->accept(this);
  78     }
  79   delete iter;
  80 }
  81
  82 void
  83 PcpVisitor::visitChildren(PcpSequence* sequence)
  84 {
  85   PcpIterator<PcpStmt*>* iter = sequence->getStmtsIterator();
  86   for(;iter->hasNext(); iter->next())
  87     {
  88       iter->get()->accept(this);
  89     }
  90   delete iter;
  91 }
  92
  93 void
  94 PcpVisitor::visitChildren(PcpGuard* guard)
  95 {
  96   guard->getCondition()->accept(this);
  97   guard->getBody()->accept(this);
  98 }
  99
 100 void
 101 PcpVisitor::visitChildren(PcpLoop* loop)
 102 {
 103   loop->getIv()->accept(this);
 104   loop->getStart()->accept(this);
 105   loop->getCondition()->accept(this);
 106   loop->getStride()->accept(this);
 107   loop->getBody()->accept(this);
 108 }
 109
 110 void
 111 PcpVisitor::visitChildren(PcpScop* scop)
 112 {
 113   PcpIterator<PcpVariable*>* varIter = scop->getVariablesIterator();
 114   for(;varIter->hasNext(); varIter->next())
 115     {
 116       varIter->get()->accept(this);
 117     }
 118   delete varIter;
 119
 120   PcpIterator<PcpParameter*>* paramIter = scop->getParametersIterator();
 121   for(;paramIter->hasNext(); paramIter->next())
 122     {
 123       paramIter->get()->accept(this);
 124     }
 125   delete paramIter;
 126
 127   scop->getBody()->accept(this);
 128 }
 129
 130 void
 131 PcpVisitor::visitChildren(PcpCompare* compare)
 132 {
 133   this->visit(compare->getLhs());
 134   this->visit(compare->getRhs());
 135 }
 136
 137
 138 void
 139 PcpVisitor::visit(PcpObject* object)
 140 {
 141   // Do nothing since this is the top level.
 142 }
 143
 144 void
 145 PcpVisitor::visit(PcpArrayType* arrayType)
 146 {
 147   this->visit((PcpObject*)arrayType);
 148 }
 149
 150 void
 151 PcpVisitor::visit(PcpArith* arith)
 152 {
 153   this->visit((PcpExpr*) arith);
 154 }
 155
 156 void
 157 PcpVisitor::visit(PcpConstant* constant)
 158 {
 159   this->visit((PcpExpr*) constant);
 160 }
 161
 162 void
 163 PcpVisitor::visit(PcpIv* iv)
 164 {
 165   this->visit((PcpExpr*) iv);
 166 }
 167
 168 void
 169 PcpVisitor::visit(PcpParameter* parameter)
 170 {
 171   this->visit((PcpExpr*) parameter);
 172 }
 173
 174 void
 175 PcpVisitor::visit(PcpCompare* compare)
 176 {
 177   this->visit((PcpBoolExpr*) compare);
 178 }
 179
 180 void
 181 PcpVisitor::visit(PcpBoolArith* boolArith)
 182 {
 183   this->visit((PcpBoolExpr*) boolArith);
 184 }
 185
 186 void
 187 PcpVisitor::visit(PcpVariable* variable)
 188 {
 189   this->visit((PcpObject*) variable);
 190 }
 191
 192 void
 193 PcpVisitor::visit(PcpArrayAccess* arrayAccess)
 194 {
 195   this->visit((PcpObject*) arrayAccess);
 196 }
 197
 198 void
 199 PcpVisitor::visit(PcpCopy* copy)
 200 {
 201   this->visit((PcpStmt*) copy);
 202 }
 203
 204 void
 205 PcpVisitor::visit(PcpUserStmt* userStmt)
 206 {
 207   this->visit((PcpStmt*) userStmt);
 208 }
 209
 210 void
 211 PcpVisitor::visit(PcpSequence* sequence)
 212 {
 213   this->visit((PcpStmt*) sequence);
 214 }
 215
 216 void
 217 PcpVisitor::visit(PcpGuard* guard)
 218 {
 219   this->visit((PcpStmt*) guard);
 220 }
 221
 222 void
 223 PcpVisitor::visit(PcpLoop* loop)
 224 {
 225   this->visit((PcpStmt*) loop);
 226 }
 227
 228 void
 229 PcpVisitor::visit(PcpScop* scop)
 230 {
 231   this->visit((PcpObject*) scop);
 232 }
 233
 234 void
 235 PcpVisitor::visit(PcpExpr* expr)
 236 {
 237   this->visit((PcpObject*) expr);
 238 }
 239
 240 void
 241 PcpVisitor::visit(PcpBoolExpr* boolExpr)
 242 {
 243   this->visit((PcpObject*) boolExpr);
 244 }
 245
 246 void
 247 PcpVisitor::visit(PcpStmt* stmt)
 248 {
 249   this->visit((PcpObject*) stmt);
 250 }
 251
 252 void
 253 PcpVisitor::visit(PcpAnnot* annot)
 254 {
 255   // Do nothing. Top level.
 256 }
 257
 258 void
 259 PcpVisitor::visit(PcpAnnotSet* annot)
 260 {
 261   // Do nothing. Top level.
 262 }
 263
 264 void
 265 PcpVisitor::visit(PcpAnnotInt* annotInt)
 266 {
 267   this->visit((PcpAnnot*) annotInt);
 268 }
 269
 270 void
 271 PcpVisitor::visit(PcpAnnotTerm* annotTerm)
 272 {
 273   this->visit((PcpAnnot*) annotTerm);
 274 }
 275
 276 void
 277 PcpVisitor::visit(PcpAnnotString* annotString)
 278 {
 279   this->visit((PcpAnnot*) annotString);
 280 }
 281
 282 void
 283 PcpVisitor::visit(PcpAnnotObject* annotObject)
 284 {
 285   this->visit((PcpAnnot*) annotObject);
 286 }
 287
 288 PcpVisitor::PcpVisitor()
 289 {
 290 }
 291