libpcp/pcp.h

   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 #ifndef _PCP_H_
  29 #define _PCP_H_
  30
  31 #include "pcp_string_buffer.h"
  32 #include "pcp_dynamic_array.h"
  33 // PCP Object
  34
  35 class PcpVisitor;
  36
  37 class PcpObject
  38 {
  39  protected:
  40   const char* name;
  41   class PcpAnnotSet* annots;
  42
  43   virtual void initialize();
  44  public:
  45   virtual const char* getName();
  46   virtual void setName(const char* aName);
  47
  48   virtual PcpAnnotSet* getAnnots();
  49   virtual void setAnnots(PcpAnnotSet* annots);
  50   virtual int getNumAnnots();
  51   virtual class PcpAnnotTerm* getAnnot(int index);
  52   virtual class PcpAnnotTerm* getAnnotWithTag(const char* tag);
  53
  54   virtual bool containsAnnotWithTag(const char* tag);
  55   virtual void addAnnot(class PcpAnnotTerm* annot);
  56
  57   virtual bool isArrayType();
  58   virtual bool isExpr();
  59   virtual bool isBoolExpr();
  60   virtual bool isVariable();
  61   virtual bool isArrayAccess();
  62   virtual bool isStmt();
  63   virtual bool isScop();
  64
  65   virtual bool isIv();
  66   virtual bool isParameter();
  67
  68   virtual class PcpArrayType* toArrayType();
  69   virtual class PcpExpr* toExpr();
  70   virtual class PcpIv* toIv();
  71   virtual class PcpBoolExpr* toBoolExpr();
  72   virtual class PcpVariable* toVariable();
  73   virtual class PcpArrayAccess* toArrayAccess();
  74   virtual class PcpStmt* toStmt();
  75   virtual class PcpScop* toScop();
  76   virtual class PcpParameter* toParameter();
  77
  78   virtual void accept(PcpVisitor* visitor) = 0;
  79
  80 };
  81
  82 class PcpAnnot
  83 {
  84  public:
  85   virtual bool isAnnotInt();
  86   virtual bool isAnnotString();
  87   virtual bool isAnnotObject();
  88   virtual bool isAnnotTerm();
  89
  90   virtual class PcpAnnotTerm* toAnnotTerm();
  91   virtual class PcpAnnotInt* toAnnotInt();
  92   virtual class PcpAnnotObject* toAnnotObject();
  93   virtual class PcpAnnotString* toAnnotString();
  94
  95   virtual void accept(PcpVisitor* visitor) = 0;
  96 };
  97
  98 // PCP Annot Set
  99
 100 class PcpAnnotSet
 101 {
 102   PcpDynamicArray<PcpAnnotTerm*>* annots;
 103
 104  private:
 105   virtual void setAnnots(PcpDynamicArray<PcpAnnotTerm*>* annots);
 106   virtual PcpDynamicArray<PcpAnnotTerm*>* getAnnots();
 107
 108  public:
 109   virtual int getNumAnnots();
 110   virtual PcpAnnotTerm* getAnnot(int index);
 111   virtual PcpAnnotTerm* getAnnotWithTag(const char* tag);
 112   virtual void addAnnot(PcpAnnotTerm* annot);
 113
 114   virtual void accept(PcpVisitor* visitor);
 115
 116   PcpAnnotSet();
 117 };
 118
 119 // PCP Annot Int
 120
 121 class PcpAnnotInt : public PcpAnnot
 122 {
 123   int value;
 124
 125   virtual void setValue(int value);
 126  public:
 127   virtual bool isAnnotInt();
 128   virtual PcpAnnotInt* toAnnotInt();
 129
 130   virtual int getValue();
 131   PcpAnnotInt();
 132   PcpAnnotInt(int value);
 133
 134   virtual void accept(PcpVisitor* visitor);
 135 };
 136
 137 class PcpAnnotTerm : public PcpAnnot
 138 {
 139  protected:
 140   const char* tag;
 141   PcpArray<PcpAnnot*>* arguments;
 142
 143   virtual void setTag(const char* tag);
 144   virtual void setArguments(PcpArray<PcpAnnot*>* arguments);
 145   virtual PcpArray<PcpAnnot*>* getArguments();
 146   virtual void setArgument(int index, PcpAnnot* annot);
 147
 148  public:
 149   virtual bool isAnnotTerm();
 150   virtual PcpAnnotTerm* toAnnotTerm();
 151   virtual const char* getTag();
 152   virtual bool tagEquals(const char* tag);
 153   virtual int getNumArguments();
 154   virtual PcpAnnot* getArgument(int index);
 155   PcpAnnotTerm(const char* tag, PcpArray<PcpAnnot*>* arguments);
 156
 157   virtual void accept(PcpVisitor* visitor) ;
 158 };
 159
 160 // PCP Annot String
 161
 162 class PcpAnnotString : public PcpAnnot
 163 {
 164  protected:
 165   const char* string;
 166   void setString(const char* string);
 167
 168  public:
 169   virtual bool isAnnotString();
 170   virtual PcpAnnotString* toAnnotString();
 171   virtual const char* getString();
 172   PcpAnnotString(const char* string);
 173
 174   virtual void accept(PcpVisitor* visitor);
 175 };
 176
 177 // PCP Annot Object
 178
 179 class PcpAnnotObject : public PcpAnnot
 180 {
 181  protected:
 182   PcpObject* object;
 183
 184   virtual void setObject(PcpObject* object);
 185
 186  public:
 187   virtual bool isAnnotObject();
 188   virtual PcpAnnotObject* toAnnotObject();
 189
 190   virtual PcpObject* getObject();
 191   PcpAnnotObject(PcpObject* object);
 192
 193   virtual void accept(PcpVisitor* visitor);
 194 };
 195
 196
 197 // PCP Annot Term Builder
 198
 199 class PcpAnnotTermBuilder
 200 {
 201  protected:
 202   const char* tag;
 203   PcpDynamicArray<PcpAnnot*>* arguments;
 204
 205   virtual void setArguments(PcpDynamicArray<PcpAnnot*>* arguments);
 206   virtual PcpDynamicArray<PcpAnnot*>* getArguments();
 207
 208
 209  public:
 210   virtual void setTag(const char* tag);
 211   virtual const char* getTag();
 212   virtual void addArgument(PcpAnnot* argument);
 213   virtual PcpAnnotTerm* createAnnot();
 214   PcpAnnotTermBuilder();
 215 };
 216
 217 // Array Type
 218
 219 class PcpArrayType : public PcpObject
 220 {
 221  protected:
 222   class PcpArray<PcpExpr*>* dimensions;
 223
 224   virtual void setDimensions(PcpArray<PcpExpr*>* dimensions);
 225   virtual class PcpArray<PcpExpr*>* getDimensions();
 226
 227  public:
 228   virtual bool isArrayType();
 229   virtual PcpArrayType* toArrayType();
 230   virtual int getNumDimensions();
 231   virtual class PcpExpr* getDimension(int index);
 232   virtual PcpIterator<PcpExpr*>* getDimensionsIterator();
 233   PcpArrayType(PcpArray<PcpExpr*>* dimensions);
 234
 235   virtual void accept(PcpVisitor* visitor);
 236 };
 237
 238 // Array Type Builder
 239
 240 class PcpArrayTypeBuilder
 241 {
 242  protected:
 243   PcpDynamicArray<PcpExpr*>* array;
 244
 245   virtual void setArray(PcpDynamicArray<PcpExpr*>* array);
 246   virtual PcpDynamicArray<PcpExpr*>* getArray();
 247
 248  public:
 249   PcpArrayTypeBuilder();
 250   virtual void addDimension(class PcpExpr* dimension);
 251   virtual void addIntDimension(int dimension);
 252   virtual PcpArrayType* createType();
 253 };
 254
 255
 256 // PCP Expr
 257
 258 class PcpExpr : public PcpObject
 259 {
 260  public:
 261   virtual bool isExpr();
 262   virtual PcpExpr* toExpr();
 263
 264   virtual bool isParameter();
 265   virtual bool isConstant();
 266   virtual bool isIv();
 267   virtual bool isArith();
 268
 269   virtual class PcpParameter* toParameter();
 270   virtual class PcpArith* toArith();
 271   virtual class PcpConstant* toConstant();
 272   virtual class PcpIv* toIv();
 273 };
 274
 275
 276 // PCP Arith
 277
 278 class PcpArithOperator
 279 {
 280  protected:
 281   enum Opcode
 282   {
 283     ARITH_OP_UKNOWN,
 284     ARITH_OP_ADD,
 285     ARITH_OP_MULTIPLY,
 286     ARITH_OP_MIN,
 287     ARITH_OP_MAX,
 288     ARITH_OP_SUBTRACT,
 289     ARITH_OP_FLOOR,
 290     ARITH_OP_CEILING
 291   };
 292
 293   Opcode op;
 294
 295   inline void setOpcode(Opcode op)
 296   {
 297     this->op = op;
 298   }
 299
 300   inline Opcode getOpcode()
 301   {
 302     return this->op;
 303   }
 304
 305   inline PcpArithOperator(Opcode op)
 306   {
 307     this->setOpcode(op);
 308   }
 309
 310  public:
 311
 312   inline PcpArithOperator()
 313   {
 314     this->setOpcode(ARITH_OP_UKNOWN);
 315   }
 316
 317
 318   static inline PcpArithOperator unknown()
 319   {
 320     return PcpArithOperator(ARITH_OP_UKNOWN);
 321   }
 322
 323   static inline PcpArithOperator add()
 324   {
 325     return PcpArithOperator(ARITH_OP_ADD);
 326   }
 327
 328   static inline PcpArithOperator multiply()
 329   {
 330     return PcpArithOperator(ARITH_OP_MULTIPLY);
 331   }
 332
 333   static inline PcpArithOperator min()
 334   {
 335     return PcpArithOperator(ARITH_OP_MIN);
 336   }
 337
 338   static inline PcpArithOperator max()
 339   {
 340     return PcpArithOperator(ARITH_OP_MAX);
 341   }
 342
 343   static inline PcpArithOperator subtract()
 344   {
 345     return PcpArithOperator(ARITH_OP_SUBTRACT);
 346   }
 347
 348   static inline PcpArithOperator floor()
 349   {
 350     return PcpArithOperator(ARITH_OP_FLOOR);
 351   }
 352
 353   static inline PcpArithOperator ceiling()
 354   {
 355     return PcpArithOperator(ARITH_OP_CEILING);
 356   }
 357
 358   inline bool isUnknown()
 359   {
 360     return this->getOpcode() == ARITH_OP_UKNOWN;
 361   }
 362
 363   inline bool isAdd()
 364   {
 365     return this->getOpcode() == ARITH_OP_ADD;
 366   }
 367
 368   inline bool isMultiply()
 369   {
 370     return this->getOpcode() == ARITH_OP_MULTIPLY;
 371   }
 372
 373   inline bool isMin()
 374   {
 375     return this->getOpcode() == ARITH_OP_MIN;
 376   }
 377
 378   inline bool isMax()
 379   {
 380     return this->getOpcode() == ARITH_OP_MAX;
 381   }
 382
 383   inline bool isSubtract()
 384   {
 385     return this->getOpcode() == ARITH_OP_SUBTRACT;
 386   }
 387
 388   inline bool isFloor()
 389   {
 390     return this->getOpcode() == ARITH_OP_FLOOR;
 391   }
 392
 393   inline bool isCeiling()
 394   {
 395     return this->getOpcode() == ARITH_OP_CEILING;
 396   }
 397
 398 };
 399
 400 class PcpArith : public PcpExpr
 401 {
 402  protected:
 403   PcpArithOperator oper;
 404   PcpArray<PcpExpr*>* operands;
 405
 406   void setOperator(PcpArithOperator oper);
 407   void setOperands(PcpArray<PcpExpr*>* operands);
 408   PcpArray<PcpExpr*>* getOperands();
 409
 410  public:
 411   virtual bool isArith();
 412   virtual PcpArith* toArith();
 413
 414   virtual PcpArithOperator getOperator();
 415   virtual int getNumOperands();
 416   virtual PcpExpr* getOperand(int index);
 417
 418   virtual PcpIterator<PcpExpr*>* getOperandsIterator();
 419
 420   PcpArith(PcpArithOperator oper, PcpArray<PcpExpr*>* operands);
 421
 422   static PcpArith* pcpArithBinaryCreate(PcpArithOperator oper,
 423                                         PcpExpr* lhs,
 424                                         PcpExpr* rhs);
 425
 426   virtual void accept(PcpVisitor* visitor);
 427 };
 428
 429 // PCP Arith builder.
 430
 431 class PcpArithBuilder
 432 {
 433  protected:
 434   PcpArithOperator oper;
 435   PcpDynamicArray<PcpExpr*>* operands;
 436
 437   void setOperands(PcpDynamicArray<PcpExpr*>* operands);
 438   PcpDynamicArray<PcpExpr*>* getOperands();
 439
 440
 441  public:
 442   virtual void setOperator(PcpArithOperator oper);
 443   virtual PcpArithOperator getOperator();
 444   virtual void addOperand(PcpExpr* operand);
 445   virtual PcpArith* createArith();
 446   PcpArithBuilder();
 447 };
 448
 449
 450 // PCP Constant
 451
 452 class PcpConstant : public PcpExpr
 453 {
 454  protected:
 455   int value;
 456
 457   virtual void setValue(int value);
 458
 459  public:
 460   virtual bool isConstant();
 461   virtual PcpConstant* toConstant();
 462
 463   virtual int getValue();
 464   PcpConstant(int value);
 465
 466   virtual void accept(PcpVisitor* visitor);
 467 };
 468
 469
 470 // PCP Induction Variable
 471
 472 class PcpIv : public PcpExpr
 473 {
 474  public:
 475   virtual bool isIv();
 476   virtual PcpIv* toIv();
 477   PcpIv(const char* name);
 478
 479   virtual void accept(PcpVisitor* visitor);
 480 };
 481
 482
 483 // PCP Parameter
 484
 485 class PcpParameter : public PcpExpr
 486 {
 487  public:
 488   virtual bool isParameter();
 489   virtual PcpParameter* toParameter();
 490
 491   PcpParameter(const char* name);
 492
 493   virtual void accept(PcpVisitor* visitor);
 494 };
 495
 496 // PCP Bool Expr
 497
 498 class PcpBoolExpr : public PcpObject
 499 {
 500  public:
 501   virtual bool isBoolExpr();
 502   virtual PcpBoolExpr* toBoolExpr();
 503
 504   virtual bool isCompare();
 505   virtual bool isBoolArith();
 506
 507   virtual class PcpCompare* toCompare();
 508   virtual class PcpBoolArith* toBoolArith();
 509 };
 510
 511 // PCP Compare
 512
 513 class PcpCompareOperator
 514 {
 515   enum Opcode
 516   {
 517     COMPARE_UNKNOWN,
 518     EQUAL,
 519     GREATER_EQUAL,
 520   };
 521
 522   Opcode op;
 523
 524   inline void setOpcode(Opcode op)
 525   {
 526     this->op = op;
 527   }
 528
 529   inline Opcode getOpcode()
 530   {
 531     return this->op;
 532   }
 533
 534   inline PcpCompareOperator(Opcode op)
 535   {
 536     setOpcode(op);
 537   }
 538  public:
 539
 540   inline PcpCompareOperator()
 541   {
 542     setOpcode(COMPARE_UNKNOWN);
 543   }
 544
 545   static inline PcpCompareOperator unknown()
 546   {
 547     return PcpCompareOperator(COMPARE_UNKNOWN);
 548   }
 549
 550   static inline PcpCompareOperator equal()
 551   {
 552     return PcpCompareOperator(EQUAL);
 553   }
 554
 555   static inline PcpCompareOperator greaterEqual()
 556   {
 557     return PcpCompareOperator(GREATER_EQUAL);
 558   }
 559
 560   inline bool isUnknown()
 561   {
 562     return this->getOpcode() == COMPARE_UNKNOWN;
 563   }
 564
 565   inline bool isEqual()
 566   {
 567     return this->getOpcode() == EQUAL;
 568   }
 569
 570   inline bool isGreaterEqual()
 571   {
 572     return this->getOpcode() == GREATER_EQUAL;
 573   }
 574
 575 };
 576
 577 class PcpCompare : public PcpBoolExpr
 578 {
 579  protected:
 580   PcpCompareOperator oper;
 581   PcpExpr* lhs;
 582   PcpExpr* rhs;
 583
 584   virtual void setOperator(PcpCompareOperator oper);
 585   virtual void setLhs(PcpExpr* lhs);
 586   virtual void setRhs(PcpExpr* rhs);
 587
 588  public:
 589   virtual bool isCompare();
 590   virtual PcpCompare* toCompare();
 591
 592   virtual PcpCompareOperator getOperator();
 593   virtual PcpExpr* getLhs();
 594   virtual PcpExpr* getRhs();
 595   PcpCompare(PcpCompareOperator oper, PcpExpr* lhs, PcpExpr* rhs);
 596
 597   virtual void accept(PcpVisitor* visitor);
 598 };
 599
 600
 601 // PCP Bool Arith
 602 class PcpBoolArithOperator
 603 {
 604  protected:
 605   enum Opcode
 606   {
 607     BOOL_UNKNOWN,
 608     BOOL_AND,
 609     BOOL_OR
 610   };
 611
 612   Opcode op;
 613
 614   inline void setOpcode(Opcode op)
 615   {
 616     this->op = op;
 617   }
 618
 619   inline Opcode getOpcode()
 620   {
 621     return this->op;
 622   }
 623
 624   inline PcpBoolArithOperator(Opcode op)
 625   {
 626     setOpcode(op);
 627   }
 628
 629  public:
 630
 631   inline PcpBoolArithOperator()
 632   {
 633     setOpcode(BOOL_UNKNOWN);
 634   }
 635
 636   static inline PcpBoolArithOperator unknown()
 637   {
 638     return PcpBoolArithOperator(BOOL_UNKNOWN);
 639   }
 640
 641   static inline PcpBoolArithOperator boolAnd()
 642   {
 643     return PcpBoolArithOperator(BOOL_AND);
 644   }
 645
 646   static inline PcpBoolArithOperator boolOr()
 647   {
 648     return PcpBoolArithOperator(BOOL_OR);
 649   }
 650
 651   inline bool isUnknown()
 652   {
 653     return this->getOpcode() == BOOL_UNKNOWN;
 654   }
 655
 656   inline bool isBoolAnd()
 657   {
 658     return this->getOpcode() == BOOL_AND;
 659   }
 660
 661   inline bool isBoolOr()
 662   {
 663     return this->getOpcode() == BOOL_OR;
 664   }
 665
 666 };
 667 class PcpBoolArith : public PcpBoolExpr
 668 {
 669  protected:
 670   PcpBoolArithOperator oper;
 671   PcpArray<PcpBoolExpr*>* operands;
 672
 673   virtual void setOperator(PcpBoolArithOperator oper);
 674   virtual void setOperands(PcpArray<PcpBoolExpr*>* operands);
 675   virtual PcpArray<PcpBoolExpr*>* getOperands();
 676
 677  public:
 678   virtual bool isBoolArith();
 679   virtual PcpBoolArith* toBoolArith();
 680   virtual PcpBoolArithOperator getOperator();
 681   virtual int getNumOperands();
 682   virtual PcpBoolExpr* getOperand(int index);
 683
 684   virtual PcpIterator<PcpBoolExpr*>* getOperandsIterator();
 685
 686   PcpBoolArith(PcpBoolArithOperator oper,
 687                PcpArray<PcpBoolExpr*>* operands);
 688   static PcpBoolArith* pcpBoolArithBinaryCreate(PcpBoolArithOperator oper,
 689                                                 PcpBoolExpr* lhs,
 690                                                 PcpBoolExpr* rhs);
 691
 692   virtual void accept(PcpVisitor* visitor);
 693 };
 694
 695
 696 class PcpBoolArithBuilder
 697 {
 698  protected:
 699   PcpBoolArithOperator oper;
 700   PcpDynamicArray<PcpBoolExpr*>* operands;
 701
 702   virtual void setOperands(PcpDynamicArray<PcpBoolExpr*>* operands);
 703
 704  public:
 705   virtual void setOperator(PcpBoolArithOperator oper);
 706   virtual PcpBoolArithOperator getOperator();
 707   virtual PcpDynamicArray<PcpBoolExpr*>* getOperands();
 708   PcpBoolArithBuilder();
 709   virtual PcpBoolArith* createBoolArith();
 710   virtual void addOperand(PcpBoolExpr* operand);
 711 };
 712
 713
 714 // PCP Variable
 715
 716 class PcpVariable : public PcpObject
 717 {
 718  protected:
 719   bool isInput;
 720   bool isOutput;
 721   PcpArrayType* type;
 722
 723   virtual void setType(PcpArrayType* type);
 724  public:
 725   virtual bool isVariable();
 726   virtual PcpVariable* toVariable();
 727
 728   virtual void setIsInput(bool isInput);
 729   virtual bool getIsInput();
 730   virtual void setIsOutput(bool isOutput);
 731   virtual bool getIsOutput();
 732   virtual PcpArrayType* getType();
 733   PcpVariable(PcpArrayType* type, const char* name);
 734
 735   virtual void accept(PcpVisitor* visitor);
 736 };
 737
 738
 739 // PCP Array Access
 740
 741 // Array operator
 742 class PcpArrayOperator
 743 {
 744  protected:
 745   enum Opcode
 746   {
 747     ARRAY_UNKNOWN,
 748     USE,
 749     DEF,
 750     MAYDEF
 751   };
 752
 753   Opcode op;
 754
 755   inline void setOpcode(Opcode op)
 756   {
 757     this->op = op;
 758   }
 759
 760   inline Opcode getOpcode()
 761   {
 762     return this->op;
 763   }
 764
 765   inline PcpArrayOperator(Opcode op)
 766   {
 767     setOpcode(op);
 768   }
 769
 770  public:
 771   inline PcpArrayOperator()
 772   {
 773     setOpcode(ARRAY_UNKNOWN);
 774   }
 775
 776   static inline PcpArrayOperator unknown()
 777   {
 778     return PcpArrayOperator(ARRAY_UNKNOWN);
 779   }
 780
 781   static inline PcpArrayOperator use()
 782   {
 783     return PcpArrayOperator(USE);
 784   }
 785
 786   static inline PcpArrayOperator def()
 787   {
 788     return PcpArrayOperator(DEF);
 789   }
 790
 791   static inline PcpArrayOperator maydef()
 792   {
 793     return PcpArrayOperator(MAYDEF);
 794   }
 795
 796   inline bool isUnknown()
 797   {
 798     return this->getOpcode() == ARRAY_UNKNOWN;
 799   }
 800
 801   inline bool isUse()
 802   {
 803     return this->getOpcode() == USE;
 804   }
 805
 806   inline bool isDef()
 807   {
 808     return this->getOpcode() == DEF;
 809   }
 810
 811   inline bool isMaydef()
 812   {
 813     return this->getOpcode() == MAYDEF;
 814   }
 815
 816 };
 817
 818 class PcpArrayAccess : public PcpObject
 819 {
 820   friend class PcpExprCanonicalizer;
 821
 822  protected:
 823   PcpArrayOperator oper;
 824   PcpVariable* base;
 825   PcpArray<PcpExpr*>* subscripts;
 826
 827   virtual void setOperator(PcpArrayOperator oper);
 828   virtual void setBase(PcpVariable* base);
 829   virtual void setSubscripts(PcpArray<PcpExpr*>* subscripts);
 830   virtual PcpArray<PcpExpr*>* getSubscripts();
 831   virtual void setSubscript(int index, PcpExpr* subscript);
 832
 833  public:
 834   virtual bool isArrayAccess();
 835   virtual PcpArrayAccess* toArrayAccess();
 836   virtual PcpArrayOperator getOperator();
 837   virtual PcpVariable* getBase();
 838   virtual int getNumSubscripts();
 839   virtual PcpExpr* getSubscript(int index);
 840   virtual bool isUse();
 841   virtual bool isDef();
 842   virtual bool isMaydef();
 843
 844   virtual PcpIterator<PcpExpr*>* getSubscriptsIterator();
 845
 846   PcpArrayAccess(PcpArrayOperator oper,
 847                  PcpVariable* base,
 848                  PcpArray<PcpExpr*>* subscripts);
 849
 850   virtual void accept(PcpVisitor* visitor);
 851 };
 852
 853
 854 // PCP Array Access Builder
 855
 856 class PcpArrayAccessBuilder
 857 {
 858  protected:
 859   PcpVariable* base;
 860   PcpArrayOperator oper;
 861   int subscriptIndex;
 862   PcpArray<PcpExpr*>* subscripts;
 863
 864   virtual void setBase(PcpVariable* base);
 865   virtual PcpVariable* getBase();
 866   virtual void setSubscriptIndex(int subscriptIndex);
 867   virtual int getSubscriptIndex();
 868   virtual PcpArray<PcpExpr*>* getSubscripts();
 869   virtual void setSubscript(int index, PcpExpr* subscript);
 870   virtual PcpExpr* getSubscript(int index);
 871   virtual int getBaseNumDimensions();
 872   virtual void setSubscripts(PcpArray<PcpExpr*>* subscripts);
 873
 874
 875  public:
 876   virtual void setOperator(PcpArrayOperator oper);
 877   virtual PcpArrayOperator getOperator();
 878   PcpArrayAccessBuilder(PcpVariable* base);
 879   virtual PcpArrayAccess* createAccess();
 880   virtual void addSubscript(PcpExpr* subscript);
 881 };
 882
 883
 884 // PCP Stmt
 885
 886 class PcpStmt : public PcpObject
 887 {
 888  public:
 889   virtual bool isStmt();
 890   virtual PcpStmt* toStmt();
 891
 892   virtual bool isCopy();
 893   virtual bool isUserStmt();
 894   virtual bool isGuard();
 895   virtual bool isLoop();
 896   virtual bool isSequence();
 897
 898   virtual class PcpCopy* toCopy();
 899   virtual class PcpUserStmt* toUserStmt();
 900   virtual class PcpGuard* toGuard();
 901   virtual class PcpLoop* toLoop();
 902   virtual class PcpSequence* toSequence();
 903 };
 904
 905 // PCP Copy Stmt
 906 class PcpCopy : public PcpStmt
 907 {
 908  protected:
 909   PcpArrayAccess* src;
 910   PcpArrayAccess* dest;
 911
 912   virtual void setSrc(PcpArrayAccess* src);
 913   virtual void setDest(PcpArrayAccess* dest);
 914
 915
 916  public:
 917   virtual bool isCopy();
 918   virtual PcpCopy* toCopy();
 919
 920   virtual PcpArrayAccess* getSrc();
 921   virtual PcpArrayAccess* getDest();
 922   PcpCopy(PcpArrayAccess* dest, PcpArrayAccess* src);
 923
 924   virtual void accept(PcpVisitor* visitor);
 925 };
 926
 927 // PCP User Stmt
 928 class PcpUserStmt : public PcpStmt
 929 {
 930  protected:
 931   PcpArray<PcpArrayAccess*>* accesses;
 932
 933   virtual void setArrayAccesses(PcpArray<PcpArrayAccess*>* accesses);
 934   virtual PcpArray<PcpArrayAccess*>* getArrayAccesses();
 935   virtual void setArrayAccess(int index, PcpArrayAccess* access);
 936
 937  public:
 938
 939   virtual bool isUserStmt();
 940   virtual PcpUserStmt* toUserStmt();
 941   virtual int getNumAccesses();
 942   virtual PcpArrayAccess* getArrayAccess(int index);
 943
 944   virtual PcpIterator<PcpArrayAccess*>* getArrayAccessesIterator();
 945
 946   PcpUserStmt(const char* name, PcpArray<PcpArrayAccess*>* accesses);
 947
 948   virtual void accept(PcpVisitor* visitor);
 949 };
 950
 951 // PCP User Stmt Builder
 952 class PcpUserStmtBuilder
 953 {
 954  protected:
 955   const char* name;
 956   PcpDynamicArray<PcpArrayAccess*>* accesses;
 957
 958   virtual void setAccesses(PcpDynamicArray<PcpArrayAccess*>* accesses);
 959   virtual PcpDynamicArray<PcpArrayAccess*>* getAccesses();
 960
 961  public:
 962   virtual const char* getName();
 963
 964   virtual void setName(const char* name);
 965   virtual void addAccess(PcpArrayAccess* access);
 966   virtual PcpUserStmt* createUserStmt();
 967   PcpUserStmtBuilder();
 968 };
 969
 970 // PCP Sequence
 971 class PcpSequence : public PcpStmt
 972 {
 973  protected:
 974   PcpArray<PcpStmt*>* stmts;
 975
 976   virtual void setStmts(PcpArray<PcpStmt*>* stmts);
 977   virtual PcpArray<PcpStmt*>* getStmts();
 978   virtual void setStmt(int index, PcpStmt* stmt);
 979
 980  public:
 981   virtual bool isSequence();
 982   virtual PcpSequence* toSequence();
 983   virtual int getNumStmts();
 984   virtual PcpStmt* getStmt(int index);
 985
 986   virtual PcpIterator<PcpStmt*>* getStmtsIterator();
 987
 988   PcpSequence(PcpArray<PcpStmt*>* stmts);
 989
 990   virtual void accept(PcpVisitor* visitor);
 991 };
 992
 993 // PCP Sequence Builder
 994 class PcpSequenceBuilder
 995 {
 996  protected:
 997   PcpDynamicArray<PcpStmt*>* stmts;
 998
 999   virtual void setStmts(PcpDynamicArray<PcpStmt*>* stmts);
1000   virtual PcpDynamicArray<PcpStmt*>* getStmts();
1001
1002  public:
1003   virtual void add(PcpStmt* stmt);
1004   virtual PcpSequence* createSequence();
1005   PcpSequenceBuilder();
1006 };
1007
1008 // PCP Guard
1009 class PcpGuard : public PcpStmt
1010 {
1011
1012   friend class PcpExprCanonicalizer;
1013
1014  protected:
1015   PcpBoolExpr* condition;
1016   PcpStmt* body;
1017
1018   virtual void setCondition(PcpBoolExpr* condition);
1019   virtual void setBody(PcpStmt* body);
1020
1021
1022  public:
1023   virtual bool isGuard();
1024   virtual PcpGuard* toGuard();
1025   virtual PcpBoolExpr* getCondition();
1026   virtual PcpStmt* getBody();
1027   PcpGuard(PcpBoolExpr* condition, PcpStmt* body);
1028
1029   virtual void accept(PcpVisitor* visitor);
1030 };
1031
1032 // PCP Loop
1033 class PcpLoop : public PcpStmt
1034 {
1035
1036   friend class PcpExprCanonicalizer;
1037
1038  protected:
1039   PcpIv* iv;
1040   PcpExpr* start;
1041   PcpBoolExpr* condition;
1042   PcpConstant* stride;
1043   PcpStmt* body;
1044
1045   virtual void setIv(PcpIv* iv);
1046   virtual void setStart(PcpExpr* start);
1047   virtual void setCondition(PcpBoolExpr* condition);
1048   virtual void setStride(PcpConstant* stride);
1049   virtual void setBody(PcpStmt* body);
1050
1051  public:
1052   virtual bool isLoop();
1053   virtual PcpLoop* toLoop();
1054   virtual PcpIv* getIv();
1055   virtual PcpExpr* getStart();
1056   virtual PcpBoolExpr* getCondition();
1057   virtual PcpConstant* getStride();
1058   virtual PcpStmt* getBody();
1059   PcpLoop(PcpIv* iv, PcpExpr* start, PcpBoolExpr* condition,
1060           PcpConstant* stride, PcpStmt* body);
1061
1062   virtual void accept(PcpVisitor* visitor);
1063 };
1064
1065 // PCP Scop
1066
1067 class PcpScop : public PcpObject
1068 {
1069  protected:
1070   PcpArray<PcpVariable*>* variables;
1071   PcpArray<PcpParameter*>* parameters;
1072   PcpStmt* body;
1073
1074   virtual void setVariables(PcpArray<PcpVariable*>* variables);
1075   virtual PcpArray<PcpVariable*>* getVariables();
1076   virtual void setParameters(PcpArray<PcpParameter*>* parameters);
1077   virtual PcpArray<PcpParameter*>* getParameters();
1078   virtual void setBody(PcpStmt* body);
1079
1080  public:
1081   virtual bool isScop();
1082   virtual PcpScop* toScop();
1083   virtual int getNumVariables();
1084   virtual int getNumParameters();
1085   virtual PcpVariable* getVariable(int index);
1086   virtual PcpParameter* getParameter(int index);
1087   virtual PcpStmt* getBody();
1088
1089   virtual PcpIterator<PcpVariable*>* getVariablesIterator();
1090   virtual PcpIterator<PcpParameter*>* getParametersIterator();
1091
1092   PcpScop(PcpArray<PcpVariable*>* variables,
1093           PcpArray<PcpParameter*>* parameters,
1094           PcpStmt* body);
1095
1096   virtual void accept(PcpVisitor* visitor);
1097 };
1098
1099 // PCP Scop Builder
1100
1101 class PcpScopBuilder
1102 {
1103  protected:
1104   PcpDynamicArray<PcpVariable*>* variables;
1105   PcpDynamicArray<PcpParameter*>* parameters;
1106   PcpStmt* body;
1107
1108   virtual void setVariables(PcpDynamicArray<PcpVariable*>* variables);
1109   virtual PcpDynamicArray<PcpVariable*>* getVariables();
1110   virtual void setParameters(PcpDynamicArray<PcpParameter*>* parameters);
1111   virtual PcpDynamicArray<PcpParameter*>* getParameters();
1112   virtual bool containsVariable(PcpVariable* variable);
1113
1114  public:
1115   virtual void addVariable(PcpVariable* variable);
1116   virtual void addParameter(PcpParameter* parameter);
1117   virtual void setBody(PcpStmt* body);
1118   virtual PcpStmt* getBody();
1119   PcpScopBuilder();
1120   PcpScop* createScop();
1121
1122 };
1123
1124 #endif // _PCP_H_