1 // Copyright (C) 2009 Free Software Foundation, Inc.
2 // Contributed by Jan Sjodin <jan.sjodin@amd.com>.
4 // This file is part of the Polyhedral Compilation Package Library (libpcp).
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.
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
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.
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.
31 #include "pcp_string_buffer.h"
32 #include "pcp_dynamic_array.h"
41 class PcpAnnotSet
* annots
;
43 virtual void initialize();
45 virtual const char* getName();
46 virtual void setName(const char* aName
);
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
);
54 virtual bool containsAnnotWithTag(const char* tag
);
55 virtual void addAnnot(class PcpAnnotTerm
* annot
);
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();
66 virtual bool isParameter();
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();
78 virtual void accept(PcpVisitor
* visitor
) = 0;
85 virtual bool isAnnotInt();
86 virtual bool isAnnotString();
87 virtual bool isAnnotObject();
88 virtual bool isAnnotTerm();
90 virtual class PcpAnnotTerm
* toAnnotTerm();
91 virtual class PcpAnnotInt
* toAnnotInt();
92 virtual class PcpAnnotObject
* toAnnotObject();
93 virtual class PcpAnnotString
* toAnnotString();
95 virtual void accept(PcpVisitor
* visitor
) = 0;
102 PcpDynamicArray
<PcpAnnotTerm
*>* annots
;
105 virtual void setAnnots(PcpDynamicArray
<PcpAnnotTerm
*>* annots
);
106 virtual PcpDynamicArray
<PcpAnnotTerm
*>* getAnnots();
109 virtual int getNumAnnots();
110 virtual PcpAnnotTerm
* getAnnot(int index
);
111 virtual PcpAnnotTerm
* getAnnotWithTag(const char* tag
);
112 virtual void addAnnot(PcpAnnotTerm
* annot
);
114 virtual void accept(PcpVisitor
* visitor
);
121 class PcpAnnotInt
: public PcpAnnot
125 virtual void setValue(int value
);
127 virtual bool isAnnotInt();
128 virtual PcpAnnotInt
* toAnnotInt();
130 virtual int getValue();
132 PcpAnnotInt(int value
);
134 virtual void accept(PcpVisitor
* visitor
);
137 class PcpAnnotTerm
: public PcpAnnot
141 PcpArray
<PcpAnnot
*>* arguments
;
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
);
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
);
157 virtual void accept(PcpVisitor
* visitor
) ;
162 class PcpAnnotString
: public PcpAnnot
166 void setString(const char* string
);
169 virtual bool isAnnotString();
170 virtual PcpAnnotString
* toAnnotString();
171 virtual const char* getString();
172 PcpAnnotString(const char* string
);
174 virtual void accept(PcpVisitor
* visitor
);
179 class PcpAnnotObject
: public PcpAnnot
184 virtual void setObject(PcpObject
* object
);
187 virtual bool isAnnotObject();
188 virtual PcpAnnotObject
* toAnnotObject();
190 virtual PcpObject
* getObject();
191 PcpAnnotObject(PcpObject
* object
);
193 virtual void accept(PcpVisitor
* visitor
);
197 // PCP Annot Term Builder
199 class PcpAnnotTermBuilder
203 PcpDynamicArray
<PcpAnnot
*>* arguments
;
205 virtual void setArguments(PcpDynamicArray
<PcpAnnot
*>* arguments
);
206 virtual PcpDynamicArray
<PcpAnnot
*>* getArguments();
210 virtual void setTag(const char* tag
);
211 virtual const char* getTag();
212 virtual void addArgument(PcpAnnot
* argument
);
213 virtual PcpAnnotTerm
* createAnnot();
214 PcpAnnotTermBuilder();
219 class PcpArrayType
: public PcpObject
222 class PcpArray
<PcpExpr
*>* dimensions
;
224 virtual void setDimensions(PcpArray
<PcpExpr
*>* dimensions
);
225 virtual class PcpArray
<PcpExpr
*>* getDimensions();
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
);
235 virtual void accept(PcpVisitor
* visitor
);
238 // Array Type Builder
240 class PcpArrayTypeBuilder
243 PcpDynamicArray
<PcpExpr
*>* array
;
245 virtual void setArray(PcpDynamicArray
<PcpExpr
*>* array
);
246 virtual PcpDynamicArray
<PcpExpr
*>* getArray();
249 PcpArrayTypeBuilder();
250 virtual void addDimension(class PcpExpr
* dimension
);
251 virtual void addIntDimension(int dimension
);
252 virtual PcpArrayType
* createType();
258 class PcpExpr
: public PcpObject
261 virtual bool isExpr();
262 virtual PcpExpr
* toExpr();
264 virtual bool isParameter();
265 virtual bool isConstant();
267 virtual bool isArith();
269 virtual class PcpParameter
* toParameter();
270 virtual class PcpArith
* toArith();
271 virtual class PcpConstant
* toConstant();
272 virtual class PcpIv
* toIv();
278 class PcpArithOperator
295 inline void setOpcode(Opcode op
)
300 inline Opcode
getOpcode()
305 inline PcpArithOperator(Opcode op
)
312 inline PcpArithOperator()
314 this->setOpcode(ARITH_OP_UKNOWN
);
318 static inline PcpArithOperator
unknown()
320 return PcpArithOperator(ARITH_OP_UKNOWN
);
323 static inline PcpArithOperator
add()
325 return PcpArithOperator(ARITH_OP_ADD
);
328 static inline PcpArithOperator
multiply()
330 return PcpArithOperator(ARITH_OP_MULTIPLY
);
333 static inline PcpArithOperator
min()
335 return PcpArithOperator(ARITH_OP_MIN
);
338 static inline PcpArithOperator
max()
340 return PcpArithOperator(ARITH_OP_MAX
);
343 static inline PcpArithOperator
subtract()
345 return PcpArithOperator(ARITH_OP_SUBTRACT
);
348 static inline PcpArithOperator
floor()
350 return PcpArithOperator(ARITH_OP_FLOOR
);
353 static inline PcpArithOperator
ceiling()
355 return PcpArithOperator(ARITH_OP_CEILING
);
358 inline bool isUnknown()
360 return this->getOpcode() == ARITH_OP_UKNOWN
;
365 return this->getOpcode() == ARITH_OP_ADD
;
368 inline bool isMultiply()
370 return this->getOpcode() == ARITH_OP_MULTIPLY
;
375 return this->getOpcode() == ARITH_OP_MIN
;
380 return this->getOpcode() == ARITH_OP_MAX
;
383 inline bool isSubtract()
385 return this->getOpcode() == ARITH_OP_SUBTRACT
;
388 inline bool isFloor()
390 return this->getOpcode() == ARITH_OP_FLOOR
;
393 inline bool isCeiling()
395 return this->getOpcode() == ARITH_OP_CEILING
;
400 class PcpArith
: public PcpExpr
403 PcpArithOperator oper
;
404 PcpArray
<PcpExpr
*>* operands
;
406 void setOperator(PcpArithOperator oper
);
407 void setOperands(PcpArray
<PcpExpr
*>* operands
);
408 PcpArray
<PcpExpr
*>* getOperands();
411 virtual bool isArith();
412 virtual PcpArith
* toArith();
414 virtual PcpArithOperator
getOperator();
415 virtual int getNumOperands();
416 virtual PcpExpr
* getOperand(int index
);
418 virtual PcpIterator
<PcpExpr
*>* getOperandsIterator();
420 PcpArith(PcpArithOperator oper
, PcpArray
<PcpExpr
*>* operands
);
422 static PcpArith
* pcpArithBinaryCreate(PcpArithOperator oper
,
426 virtual void accept(PcpVisitor
* visitor
);
429 // PCP Arith builder.
431 class PcpArithBuilder
434 PcpArithOperator oper
;
435 PcpDynamicArray
<PcpExpr
*>* operands
;
437 void setOperands(PcpDynamicArray
<PcpExpr
*>* operands
);
438 PcpDynamicArray
<PcpExpr
*>* getOperands();
442 virtual void setOperator(PcpArithOperator oper
);
443 virtual PcpArithOperator
getOperator();
444 virtual void addOperand(PcpExpr
* operand
);
445 virtual PcpArith
* createArith();
452 class PcpConstant
: public PcpExpr
457 virtual void setValue(int value
);
460 virtual bool isConstant();
461 virtual PcpConstant
* toConstant();
463 virtual int getValue();
464 PcpConstant(int value
);
466 virtual void accept(PcpVisitor
* visitor
);
470 // PCP Induction Variable
472 class PcpIv
: public PcpExpr
476 virtual PcpIv
* toIv();
477 PcpIv(const char* name
);
479 virtual void accept(PcpVisitor
* visitor
);
485 class PcpParameter
: public PcpExpr
488 virtual bool isParameter();
489 virtual PcpParameter
* toParameter();
491 PcpParameter(const char* name
);
493 virtual void accept(PcpVisitor
* visitor
);
498 class PcpBoolExpr
: public PcpObject
501 virtual bool isBoolExpr();
502 virtual PcpBoolExpr
* toBoolExpr();
504 virtual bool isCompare();
505 virtual bool isBoolArith();
507 virtual class PcpCompare
* toCompare();
508 virtual class PcpBoolArith
* toBoolArith();
513 class PcpCompareOperator
524 inline void setOpcode(Opcode op
)
529 inline Opcode
getOpcode()
534 inline PcpCompareOperator(Opcode op
)
540 inline PcpCompareOperator()
542 setOpcode(COMPARE_UNKNOWN
);
545 static inline PcpCompareOperator
unknown()
547 return PcpCompareOperator(COMPARE_UNKNOWN
);
550 static inline PcpCompareOperator
equal()
552 return PcpCompareOperator(EQUAL
);
555 static inline PcpCompareOperator
greaterEqual()
557 return PcpCompareOperator(GREATER_EQUAL
);
560 inline bool isUnknown()
562 return this->getOpcode() == COMPARE_UNKNOWN
;
565 inline bool isEqual()
567 return this->getOpcode() == EQUAL
;
570 inline bool isGreaterEqual()
572 return this->getOpcode() == GREATER_EQUAL
;
577 class PcpCompare
: public PcpBoolExpr
580 PcpCompareOperator oper
;
584 virtual void setOperator(PcpCompareOperator oper
);
585 virtual void setLhs(PcpExpr
* lhs
);
586 virtual void setRhs(PcpExpr
* rhs
);
589 virtual bool isCompare();
590 virtual PcpCompare
* toCompare();
592 virtual PcpCompareOperator
getOperator();
593 virtual PcpExpr
* getLhs();
594 virtual PcpExpr
* getRhs();
595 PcpCompare(PcpCompareOperator oper
, PcpExpr
* lhs
, PcpExpr
* rhs
);
597 virtual void accept(PcpVisitor
* visitor
);
602 class PcpBoolArithOperator
614 inline void setOpcode(Opcode op
)
619 inline Opcode
getOpcode()
624 inline PcpBoolArithOperator(Opcode op
)
631 inline PcpBoolArithOperator()
633 setOpcode(BOOL_UNKNOWN
);
636 static inline PcpBoolArithOperator
unknown()
638 return PcpBoolArithOperator(BOOL_UNKNOWN
);
641 static inline PcpBoolArithOperator
boolAnd()
643 return PcpBoolArithOperator(BOOL_AND
);
646 static inline PcpBoolArithOperator
boolOr()
648 return PcpBoolArithOperator(BOOL_OR
);
651 inline bool isUnknown()
653 return this->getOpcode() == BOOL_UNKNOWN
;
656 inline bool isBoolAnd()
658 return this->getOpcode() == BOOL_AND
;
661 inline bool isBoolOr()
663 return this->getOpcode() == BOOL_OR
;
667 class PcpBoolArith
: public PcpBoolExpr
670 PcpBoolArithOperator oper
;
671 PcpArray
<PcpBoolExpr
*>* operands
;
673 virtual void setOperator(PcpBoolArithOperator oper
);
674 virtual void setOperands(PcpArray
<PcpBoolExpr
*>* operands
);
675 virtual PcpArray
<PcpBoolExpr
*>* getOperands();
678 virtual bool isBoolArith();
679 virtual PcpBoolArith
* toBoolArith();
680 virtual PcpBoolArithOperator
getOperator();
681 virtual int getNumOperands();
682 virtual PcpBoolExpr
* getOperand(int index
);
684 virtual PcpIterator
<PcpBoolExpr
*>* getOperandsIterator();
686 PcpBoolArith(PcpBoolArithOperator oper
,
687 PcpArray
<PcpBoolExpr
*>* operands
);
688 static PcpBoolArith
* pcpBoolArithBinaryCreate(PcpBoolArithOperator oper
,
692 virtual void accept(PcpVisitor
* visitor
);
696 class PcpBoolArithBuilder
699 PcpBoolArithOperator oper
;
700 PcpDynamicArray
<PcpBoolExpr
*>* operands
;
702 virtual void setOperands(PcpDynamicArray
<PcpBoolExpr
*>* operands
);
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
);
716 class PcpVariable
: public PcpObject
723 virtual void setType(PcpArrayType
* type
);
725 virtual bool isVariable();
726 virtual PcpVariable
* toVariable();
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
);
735 virtual void accept(PcpVisitor
* visitor
);
742 class PcpArrayOperator
755 inline void setOpcode(Opcode op
)
760 inline Opcode
getOpcode()
765 inline PcpArrayOperator(Opcode op
)
771 inline PcpArrayOperator()
773 setOpcode(ARRAY_UNKNOWN
);
776 static inline PcpArrayOperator
unknown()
778 return PcpArrayOperator(ARRAY_UNKNOWN
);
781 static inline PcpArrayOperator
use()
783 return PcpArrayOperator(USE
);
786 static inline PcpArrayOperator
def()
788 return PcpArrayOperator(DEF
);
791 static inline PcpArrayOperator
maydef()
793 return PcpArrayOperator(MAYDEF
);
796 inline bool isUnknown()
798 return this->getOpcode() == ARRAY_UNKNOWN
;
803 return this->getOpcode() == USE
;
808 return this->getOpcode() == DEF
;
811 inline bool isMaydef()
813 return this->getOpcode() == MAYDEF
;
818 class PcpArrayAccess
: public PcpObject
820 friend class PcpExprCanonicalizer
;
823 PcpArrayOperator oper
;
825 PcpArray
<PcpExpr
*>* subscripts
;
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
);
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();
844 virtual PcpIterator
<PcpExpr
*>* getSubscriptsIterator();
846 PcpArrayAccess(PcpArrayOperator oper
,
848 PcpArray
<PcpExpr
*>* subscripts
);
850 virtual void accept(PcpVisitor
* visitor
);
854 // PCP Array Access Builder
856 class PcpArrayAccessBuilder
860 PcpArrayOperator oper
;
862 PcpArray
<PcpExpr
*>* subscripts
;
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
);
876 virtual void setOperator(PcpArrayOperator oper
);
877 virtual PcpArrayOperator
getOperator();
878 PcpArrayAccessBuilder(PcpVariable
* base
);
879 virtual PcpArrayAccess
* createAccess();
880 virtual void addSubscript(PcpExpr
* subscript
);
886 class PcpStmt
: public PcpObject
889 virtual bool isStmt();
890 virtual PcpStmt
* toStmt();
892 virtual bool isCopy();
893 virtual bool isUserStmt();
894 virtual bool isGuard();
895 virtual bool isLoop();
896 virtual bool isSequence();
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();
906 class PcpCopy
: public PcpStmt
910 PcpArrayAccess
* dest
;
912 virtual void setSrc(PcpArrayAccess
* src
);
913 virtual void setDest(PcpArrayAccess
* dest
);
917 virtual bool isCopy();
918 virtual PcpCopy
* toCopy();
920 virtual PcpArrayAccess
* getSrc();
921 virtual PcpArrayAccess
* getDest();
922 PcpCopy(PcpArrayAccess
* dest
, PcpArrayAccess
* src
);
924 virtual void accept(PcpVisitor
* visitor
);
928 class PcpUserStmt
: public PcpStmt
931 PcpArray
<PcpArrayAccess
*>* accesses
;
933 virtual void setArrayAccesses(PcpArray
<PcpArrayAccess
*>* accesses
);
934 virtual PcpArray
<PcpArrayAccess
*>* getArrayAccesses();
935 virtual void setArrayAccess(int index
, PcpArrayAccess
* access
);
939 virtual bool isUserStmt();
940 virtual PcpUserStmt
* toUserStmt();
941 virtual int getNumAccesses();
942 virtual PcpArrayAccess
* getArrayAccess(int index
);
944 virtual PcpIterator
<PcpArrayAccess
*>* getArrayAccessesIterator();
946 PcpUserStmt(const char* name
, PcpArray
<PcpArrayAccess
*>* accesses
);
948 virtual void accept(PcpVisitor
* visitor
);
951 // PCP User Stmt Builder
952 class PcpUserStmtBuilder
956 PcpDynamicArray
<PcpArrayAccess
*>* accesses
;
958 virtual void setAccesses(PcpDynamicArray
<PcpArrayAccess
*>* accesses
);
959 virtual PcpDynamicArray
<PcpArrayAccess
*>* getAccesses();
962 virtual const char* getName();
964 virtual void setName(const char* name
);
965 virtual void addAccess(PcpArrayAccess
* access
);
966 virtual PcpUserStmt
* createUserStmt();
967 PcpUserStmtBuilder();
971 class PcpSequence
: public PcpStmt
974 PcpArray
<PcpStmt
*>* stmts
;
976 virtual void setStmts(PcpArray
<PcpStmt
*>* stmts
);
977 virtual PcpArray
<PcpStmt
*>* getStmts();
978 virtual void setStmt(int index
, PcpStmt
* stmt
);
981 virtual bool isSequence();
982 virtual PcpSequence
* toSequence();
983 virtual int getNumStmts();
984 virtual PcpStmt
* getStmt(int index
);
986 virtual PcpIterator
<PcpStmt
*>* getStmtsIterator();
988 PcpSequence(PcpArray
<PcpStmt
*>* stmts
);
990 virtual void accept(PcpVisitor
* visitor
);
993 // PCP Sequence Builder
994 class PcpSequenceBuilder
997 PcpDynamicArray
<PcpStmt
*>* stmts
;
999 virtual void setStmts(PcpDynamicArray
<PcpStmt
*>* stmts
);
1000 virtual PcpDynamicArray
<PcpStmt
*>* getStmts();
1003 virtual void add(PcpStmt
* stmt
);
1004 virtual PcpSequence
* createSequence();
1005 PcpSequenceBuilder();
1009 class PcpGuard
: public PcpStmt
1012 friend class PcpExprCanonicalizer
;
1015 PcpBoolExpr
* condition
;
1018 virtual void setCondition(PcpBoolExpr
* condition
);
1019 virtual void setBody(PcpStmt
* body
);
1023 virtual bool isGuard();
1024 virtual PcpGuard
* toGuard();
1025 virtual PcpBoolExpr
* getCondition();
1026 virtual PcpStmt
* getBody();
1027 PcpGuard(PcpBoolExpr
* condition
, PcpStmt
* body
);
1029 virtual void accept(PcpVisitor
* visitor
);
1033 class PcpLoop
: public PcpStmt
1036 friend class PcpExprCanonicalizer
;
1041 PcpBoolExpr
* condition
;
1042 PcpConstant
* stride
;
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
);
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
);
1062 virtual void accept(PcpVisitor
* visitor
);
1067 class PcpScop
: public PcpObject
1070 PcpArray
<PcpVariable
*>* variables
;
1071 PcpArray
<PcpParameter
*>* parameters
;
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
);
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();
1089 virtual PcpIterator
<PcpVariable
*>* getVariablesIterator();
1090 virtual PcpIterator
<PcpParameter
*>* getParametersIterator();
1092 PcpScop(PcpArray
<PcpVariable
*>* variables
,
1093 PcpArray
<PcpParameter
*>* parameters
,
1096 virtual void accept(PcpVisitor
* visitor
);
1101 class PcpScopBuilder
1104 PcpDynamicArray
<PcpVariable
*>* variables
;
1105 PcpDynamicArray
<PcpParameter
*>* parameters
;
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
);
1115 virtual void addVariable(PcpVariable
* variable
);
1116 virtual void addParameter(PcpParameter
* parameter
);
1117 virtual void setBody(PcpStmt
* body
);
1118 virtual PcpStmt
* getBody();
1120 PcpScop
* createScop();