llvm.org GIT mirror llvm / e4d87aa
For PR950: This patch removes the SetCC instructions and replaces them with the ICmp and FCmp instructions. The SetCondInst instruction has been removed and been replaced with ICmpInst and FCmpInst. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32751 91177308-0d34-0410-b5e6-96231b3b80d8 Reid Spencer 12 years ago
87 changed file(s) with 8592 addition(s) and 7119 deletion(s). Raw diff Collapse all Expand all
5757 BasicBlock* RecurseBB = new BasicBlock("recurse", FibF);
5858
5959 // Create the "if (arg < 2) goto exitbb"
60 Value *CondInst = BinaryOperator::createSetLE(ArgX, Two, "cond", BB);
60 Value *CondInst = new ICmpInst(ICmpInst::ICMP_SLE, ArgX, Two, "cond", BB);
6161 new BranchInst(RetBB, RecurseBB, CondInst, BB);
6262
6363 // Create: ret int 1
8282 BasicBlock* RecurseBB = new BasicBlock("recurse", FibF);
8383
8484 // Create the "if (arg < 2) goto exitbb"
85 Value *CondInst = BinaryOperator::createSetLE(ArgX, Two, "cond", BB);
85 Value *CondInst = new ICmpInst(ICmpInst::ICMP_SLE, ArgX, Two, "cond", BB);
8686 new BranchInst(RetBB, RecurseBB, CondInst, BB);
8787
8888 // Create: ret int 1
425425 /// looking at this is that it returns the first iteration number where the
426426 /// value is not in the condition, thus computing the exit count. If the
427427 /// iteration count can't be computed, an instance of SCEVCouldNotCompute is
428 /// returned.
429 SCEVHandle getNumIterationsInRange(ConstantRange Range) const;
428 /// returned. The isSigned parameter indicates whether the ConstantRange
429 /// should be treated as signed or unsigned.
430 SCEVHandle getNumIterationsInRange(ConstantRange Range,
431 bool isSigned) const;
430432
431433 SCEVHandle replaceSymbolicValuesWithConcrete(const SCEVHandle &Sym,
432434 const SCEVHandle &Conc) const;
495495 // ConstantExprs in intermediate forms.
496496 static Constant *getTy(const Type *Ty, unsigned Opcode,
497497 Constant *C1, Constant *C2);
498 static Constant *getCompareTy(unsigned Opcode, unsigned short pred,
499 Constant *C1, Constant *C2);
498 static Constant *getCompareTy(unsigned short pred, Constant *C1,
499 Constant *C2);
500500 static Constant *getShiftTy(const Type *Ty,
501501 unsigned Opcode, Constant *C1, Constant *C2);
502502 static Constant *getSelectTy(const Type *Ty,
603603 static Constant *get(unsigned Opcode, Constant *C1, Constant *C2);
604604
605605 /// @brief Return an ICmp or FCmp comparison operator constant expression.
606 static Constant *getCompare(unsigned Opcode, unsigned short pred,
607 Constant *C1, Constant *C2);
606 static Constant *getCompare(unsigned short pred, Constant *C1, Constant *C2);
608607
609608 /// ConstantExpr::get* - Return some common constants without having to
610609 /// specify the full Instruction::OPCODE identifier.
623622 static Constant *getAnd(Constant *C1, Constant *C2);
624623 static Constant *getOr(Constant *C1, Constant *C2);
625624 static Constant *getXor(Constant *C1, Constant *C2);
626 static Constant *getSetEQ(Constant *C1, Constant *C2);
627 static Constant *getSetNE(Constant *C1, Constant *C2);
628 static Constant *getSetLT(Constant *C1, Constant *C2);
629 static Constant *getSetGT(Constant *C1, Constant *C2);
630 static Constant *getSetLE(Constant *C1, Constant *C2);
631 static Constant *getSetGE(Constant *C1, Constant *C2);
632625 static Constant* getICmp(unsigned short pred, Constant* LHS, Constant* RHS);
633626 static Constant* getFCmp(unsigned short pred, Constant* LHS, Constant* RHS);
634627 static Constant *getShl(Constant *C1, Constant *C2);
542542 /// @brief Determine if this is an equals/not equals predicate.
543543 bool isEquality();
544544
545 /// @returns true if the predicate is unsigned, false otherwise.
546 /// @brief Determine if the predicate is an unsigned operation.
547 static bool isUnsigned(unsigned short predicate);
548
549 /// @returns true if the predicate is signed, false otherwise.
550 /// @brief Determine if the predicate is an signed operation.
551 static bool isSigned(unsigned short predicate);
552
553 /// @brief Determine if the predicate is an ordered operation.
554 static bool isOrdered(unsigned short predicate);
555
556 /// @brief Determine if the predicate is an unordered operation.
557 static bool isUnordered(unsigned short predicate);
558
545559 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
546560 static inline bool classof(const CmpInst *) { return true; }
547561 static inline bool classof(const Instruction *I) {
117117 HANDLE_BINARY_INST(16, And , BinaryOperator)
118118 HANDLE_BINARY_INST(17, Or , BinaryOperator)
119119 HANDLE_BINARY_INST(18, Xor , BinaryOperator)
120
121 // Binary comparison operators...
122 HANDLE_BINARY_INST(19, SetEQ , SetCondInst)
123 HANDLE_BINARY_INST(20, SetNE , SetCondInst)
124 HANDLE_BINARY_INST(21, SetLE , SetCondInst)
125 HANDLE_BINARY_INST(22, SetGE , SetCondInst)
126 HANDLE_BINARY_INST(23, SetLT , SetCondInst)
127 HANDLE_BINARY_INST(24, SetGT , SetCondInst)
128 LAST_BINARY_INST(24)
120 LAST_BINARY_INST(18)
129121
130122 // Memory operators...
131 FIRST_MEMORY_INST(25)
132 HANDLE_MEMORY_INST(25, Malloc, MallocInst) // Heap management instructions
133 HANDLE_MEMORY_INST(26, Free , FreeInst )
134 HANDLE_MEMORY_INST(27, Alloca, AllocaInst) // Stack management
135 HANDLE_MEMORY_INST(28, Load , LoadInst ) // Memory manipulation instrs
136 HANDLE_MEMORY_INST(29, Store , StoreInst )
137 HANDLE_MEMORY_INST(30, GetElementPtr, GetElementPtrInst)
138 LAST_MEMORY_INST(30)
123 FIRST_MEMORY_INST(19)
124 HANDLE_MEMORY_INST(19, Malloc, MallocInst) // Heap management instructions
125 HANDLE_MEMORY_INST(20, Free , FreeInst )
126 HANDLE_MEMORY_INST(21, Alloca, AllocaInst) // Stack management
127 HANDLE_MEMORY_INST(22, Load , LoadInst ) // Memory manipulation instrs
128 HANDLE_MEMORY_INST(23, Store , StoreInst )
129 HANDLE_MEMORY_INST(24, GetElementPtr, GetElementPtrInst)
130 LAST_MEMORY_INST(24)
139131
140132 // Cast operators ...
141133 // NOTE: The order matters here because CastInst::isEliminableCastPair
142134 // NOTE: (see Instructions.cpp) encodes a table based on this ordering.
143 FIRST_CAST_INST(31)
144 HANDLE_CAST_INST(31, Trunc , TruncInst ) // Truncate integers
145 HANDLE_CAST_INST(32, ZExt , ZExtInst ) // Zero extend integers
146 HANDLE_CAST_INST(33, SExt , SExtInst ) // Sign extend integers
147 HANDLE_CAST_INST(34, FPToUI , FPToUIInst ) // floating point -> UInt
148 HANDLE_CAST_INST(35, FPToSI , FPToSIInst ) // floating point -> SInt
149 HANDLE_CAST_INST(36, UIToFP , UIToFPInst ) // UInt -> floating point
150 HANDLE_CAST_INST(37, SIToFP , SIToFPInst ) // SInt -> floating point
151 HANDLE_CAST_INST(38, FPTrunc , FPTruncInst ) // Truncate floating point
152 HANDLE_CAST_INST(39, FPExt , FPExtInst ) // Extend floating point
153 HANDLE_CAST_INST(40, PtrToInt, PtrToIntInst) // Pointer -> Integer
154 HANDLE_CAST_INST(41, IntToPtr, IntToPtrInst) // Integer -> Pointer
155 HANDLE_CAST_INST(42, BitCast , BitCastInst ) // Type cast
156 LAST_CAST_INST(42)
135 FIRST_CAST_INST(25)
136 HANDLE_CAST_INST(25, Trunc , TruncInst ) // Truncate integers
137 HANDLE_CAST_INST(26, ZExt , ZExtInst ) // Zero extend integers
138 HANDLE_CAST_INST(27, SExt , SExtInst ) // Sign extend integers
139 HANDLE_CAST_INST(28, FPToUI , FPToUIInst ) // floating point -> UInt
140 HANDLE_CAST_INST(29, FPToSI , FPToSIInst ) // floating point -> SInt
141 HANDLE_CAST_INST(30, UIToFP , UIToFPInst ) // UInt -> floating point
142 HANDLE_CAST_INST(31, SIToFP , SIToFPInst ) // SInt -> floating point
143 HANDLE_CAST_INST(32, FPTrunc , FPTruncInst ) // Truncate floating point
144 HANDLE_CAST_INST(33, FPExt , FPExtInst ) // Extend floating point
145 HANDLE_CAST_INST(34, PtrToInt, PtrToIntInst) // Pointer -> Integer
146 HANDLE_CAST_INST(35, IntToPtr, IntToPtrInst) // Integer -> Pointer
147 HANDLE_CAST_INST(36, BitCast , BitCastInst ) // Type cast
148 LAST_CAST_INST(36)
157149
158150 // Other operators...
159 FIRST_OTHER_INST(43)
160 HANDLE_OTHER_INST(43, ICmp , ICmpInst ) // Integer comparison instruction
161 HANDLE_OTHER_INST(44, FCmp , FCmpInst ) // Floating point comparison instr.
162 HANDLE_OTHER_INST(45, PHI , PHINode ) // PHI node instruction
163 HANDLE_OTHER_INST(46, Call , CallInst ) // Call a function
164 HANDLE_OTHER_INST(47, Shl , ShiftInst ) // Shift Left operations (logical)
165 HANDLE_OTHER_INST(48, LShr , ShiftInst ) // Logical Shift right (unsigned)
166 HANDLE_OTHER_INST(49, AShr , ShiftInst ) // Arithmetic shift right (signed)
167 HANDLE_OTHER_INST(50, Select , SelectInst ) // select instruction
168 HANDLE_OTHER_INST(51, UserOp1, Instruction) // May be used internally in a pass
169 HANDLE_OTHER_INST(52, UserOp2, Instruction) // Internal to passes only
170 HANDLE_OTHER_INST(53, VAArg , VAArgInst ) // vaarg instruction
171 HANDLE_OTHER_INST(54, ExtractElement, ExtractElementInst)// extract from vector.
172 HANDLE_OTHER_INST(55, InsertElement, InsertElementInst) // insert into vector
173 HANDLE_OTHER_INST(56, ShuffleVector, ShuffleVectorInst) // shuffle two vectors.
174 LAST_OTHER_INST(56)
151 FIRST_OTHER_INST(37)
152 HANDLE_OTHER_INST(37, ICmp , ICmpInst ) // Integer comparison instruction
153 HANDLE_OTHER_INST(38, FCmp , FCmpInst ) // Floating point comparison instr.
154 HANDLE_OTHER_INST(39, PHI , PHINode ) // PHI node instruction
155 HANDLE_OTHER_INST(40, Call , CallInst ) // Call a function
156 HANDLE_OTHER_INST(41, Shl , ShiftInst ) // Shift Left operations (logical)
157 HANDLE_OTHER_INST(42, LShr , ShiftInst ) // Logical Shift right (unsigned)
158 HANDLE_OTHER_INST(43, AShr , ShiftInst ) // Arithmetic shift right (signed)
159 HANDLE_OTHER_INST(44, Select , SelectInst ) // select instruction
160 HANDLE_OTHER_INST(45, UserOp1, Instruction) // May be used internally in a pass
161 HANDLE_OTHER_INST(46, UserOp2, Instruction) // Internal to passes only
162 HANDLE_OTHER_INST(47, VAArg , VAArgInst ) // vaarg instruction
163 HANDLE_OTHER_INST(48, ExtractElement, ExtractElementInst)// extract from vector.
164 HANDLE_OTHER_INST(49, InsertElement, InsertElementInst) // insert into vector
165 HANDLE_OTHER_INST(50, ShuffleVector, ShuffleVectorInst) // shuffle two vectors.
166 LAST_OTHER_INST(50)
175167
176168 #undef FIRST_TERM_INST
177169 #undef HANDLE_TERM_INST
7070 /// extra information (e.g. load is volatile) agree.
7171 bool isIdenticalTo(Instruction *I) const;
7272
73 /// This function determines if the specified instruction executes the same
74 /// operation as the current one. This means that the opcodes, type, operand
75 /// types and any other factors affecting the operation must be the same. This
76 /// is similar to isIdenticalTo except the operands themselves don't have to
77 /// be identical.
78 /// @returns true if the specified instruction is the same operation as
79 /// the current one.
80 /// @brief Determine if one instruction is the same operation as another.
81 bool isSameOperationAs(Instruction *I) const;
82
7383 /// use_back - Specialize the methods defined in Value, as we know that an
7484 /// instruction can only be used by other instructions.
7585 Instruction *use_back() { return cast(*use_begin());}
154164 bool isCommutative() const { return isCommutative(getOpcode()); }
155165 static bool isCommutative(unsigned op);
156166
157 /// isComparison - Return true if the instruction is a Set* instruction:
158 ///
159 bool isComparison() const { return isComparison(getOpcode()); }
160 static bool isComparison(unsigned op);
161
162
163167 /// isTrappingInstruction - Return true if the instruction may trap.
164168 ///
165169 bool isTrapping() const {
439439 ICMP_SLT = 40, ///< signed less than
440440 ICMP_SLE = 41, ///< signed less or equal
441441 FIRST_ICMP_PREDICATE = ICMP_EQ,
442 LAST_ICMP_PREDICATE = ICMP_SLE
442 LAST_ICMP_PREDICATE = ICMP_SLE,
443 BAD_ICMP_PREDICATE = ICMP_SLE + 1
443444 };
444445
445446 /// @brief Constructor with insert-before-instruction semantics.
489490 /// This is a static version that you can use without an instruction
490491 /// available.
491492 /// @brief Return the predicate as if the operands were swapped.
492 static Predicate getSwappedPredicate(Predicate Opcode);
493 static Predicate getSwappedPredicate(Predicate pred);
494
495 /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
496 /// @returns the predicate that would be the result if the operand were
497 /// regarded as signed.
498 /// @brief Return the signed version of the predicate
499 Predicate getSignedPredicate() const {
500 return getSignedPredicate(getPredicate());
501 }
502
503 /// This is a static version that you can use without an instruction.
504 /// @brief Return the signed version of the predicate.
505 static Predicate getSignedPredicate(Predicate pred);
493506
494507 /// This also tests for commutativity. If isEquality() returns true then
495 /// the predicate is also commutative. Only the equality predicates are
496 /// commutative.
508 /// the predicate is also commutative.
497509 /// @returns true if the predicate of this instruction is EQ or NE.
498510 /// @brief Determine if this is an equality predicate.
499511 bool isEquality() const {
500512 return SubclassData == ICMP_EQ || SubclassData == ICMP_NE;
501513 }
514
515 /// @returns true if the predicate of this ICmpInst is commutative
516 /// @brief Determine if this relation is commutative.
502517 bool isCommutative() const { return isEquality(); }
503518
504519 /// @returns true if the predicate is relational (not EQ or NE).
506521 bool isRelational() const {
507522 return !isEquality();
508523 }
524
525 /// @returns true if the predicate of this ICmpInst is signed, false otherwise
526 /// @brief Determine if this instruction's predicate is signed.
527 bool isSignedPredicate() { return isSignedPredicate(getPredicate()); }
528
529 /// @returns true if the predicate provided is signed, false otherwise
530 /// @brief Determine if the predicate is signed.
531 static bool isSignedPredicate(Predicate pred);
509532
510533 /// Exchange the two operands to this instruction in such a way that it does
511534 /// not modify the semantics of the instruction. The predicate value may be
558581 FCMP_UNE =14, ///< 1 1 1 0 True if unordered or not equal
559582 FCMP_TRUE =15, ///< 1 1 1 1 Always true (always folded)
560583 FIRST_FCMP_PREDICATE = FCMP_FALSE,
561 LAST_FCMP_PREDICATE = FCMP_TRUE
584 LAST_FCMP_PREDICATE = FCMP_TRUE,
585 BAD_FCMP_PREDICATE = FCMP_TRUE + 1
562586 };
563587
564588 /// @brief Constructor with insert-before-instruction semantics.
644668 return isa(V) && classof(cast(V));
645669 }
646670 };
647
648
649 //===----------------------------------------------------------------------===//
650 // SetCondInst Class
651 //===----------------------------------------------------------------------===//
652
653 /// SetCondInst class - Represent a setCC operator, where CC is eq, ne, lt, gt,
654 /// le, or ge.
655 ///
656 class SetCondInst : public BinaryOperator {
657 public:
658 SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS,
659 const std::string &Name = "", Instruction *InsertBefore = 0);
660 SetCondInst(BinaryOps Opcode, Value *LHS, Value *RHS,
661 const std::string &Name, BasicBlock *InsertAtEnd);
662
663 /// getInverseCondition - Return the inverse of the current condition opcode.
664 /// For example seteq -> setne, setgt -> setle, setlt -> setge, etc...
665 ///
666 BinaryOps getInverseCondition() const {
667 return getInverseCondition(getOpcode());
668 }
669
670 /// getInverseCondition - Static version that you can use without an
671 /// instruction available.
672 ///
673 static BinaryOps getInverseCondition(BinaryOps Opcode);
674
675 /// getSwappedCondition - Return the condition opcode that would be the result
676 /// of exchanging the two operands of the setcc instruction without changing
677 /// the result produced. Thus, seteq->seteq, setle->setge, setlt->setgt, etc.
678 ///
679 BinaryOps getSwappedCondition() const {
680 return getSwappedCondition(getOpcode());
681 }
682
683 /// getSwappedCondition - Static version that you can use without an
684 /// instruction available.
685 ///
686 static BinaryOps getSwappedCondition(BinaryOps Opcode);
687
688 /// isEquality - Return true if this comparison is an ==/!= comparison.
689 ///
690 bool isEquality() const {
691 return getOpcode() == SetEQ || getOpcode() == SetNE;
692 }
693
694 /// isRelational - Return true if this comparison is a /<=/>= comparison.
695 ///
696 bool isRelational() const {
697 return !isEquality();
698 }
699
700 // Methods for support type inquiry through isa, cast, and dyn_cast:
701 static inline bool classof(const SetCondInst *) { return true; }
702 static inline bool classof(const Instruction *I) {
703 return I->getOpcode() == SetEQ || I->getOpcode() == SetNE ||
704 I->getOpcode() == SetLE || I->getOpcode() == SetGE ||
705 I->getOpcode() == SetLT || I->getOpcode() == SetGT;
706 }
707 static inline bool classof(const Value *V) {
708 return isa(V) && classof(cast(V));
709 }
710 };
711
712671
713672 //===----------------------------------------------------------------------===//
714673 // CallInst Class
3535 #include
3636 #include
3737
38 //#define USE_OLD_PASSMANAGER 1
38 #define USE_OLD_PASSMANAGER 1
3939
4040 namespace llvm {
4141
1111 // constant, which MAY wrap around the end of the numeric range. To do this, it
1212 // keeps track of a [lower, upper) bound, which specifies an interval just like
1313 // STL iterators. When used with boolean values, the following are important
14 // ranges (other integral ranges use min/max values for special range values):
14 // ranges: :
1515 //
1616 // [F, F) = {} = Empty set
1717 // [T, F) = {T}
1818 // [F, T) = {F}
1919 // [T, T) = {F, T} = Full set
2020 //
21 // The other integral ranges use min/max values for special range values. For
22 // example, for 8-bit types, it uses:
23 // [0, 0) = {} = Empty set
24 // [255, 255) = {0..255} = Full Set
25 //
26 // Note that ConstantRange always keeps unsigned values.
2127 //===----------------------------------------------------------------------===//
2228
2329 #ifndef LLVM_SUPPORT_CONSTANT_RANGE_H
5056 ///
5157 ConstantRange(Constant *Lower, Constant *Upper);
5258
53 /// Initialize a set of values that all satisfy the condition with C.
54 ///
55 ConstantRange(unsigned SetCCOpcode, ConstantIntegral *C);
59 /// Initialize a set of values that all satisfy the predicate with C. The
60 /// predicate should be either an ICmpInst::Predicate or FCmpInst::Predicate
61 /// value.
62 /// @brief Get a range for a relation with a constant integral.
63 ConstantRange(unsigned short predicate, ConstantIntegral *C);
5664
5765 /// getLower - Return the lower value for this range...
5866 ///
7886 /// isWrappedSet - Return true if this set wraps around the top of the range,
7987 /// for example: [100, 8)
8088 ///
81 bool isWrappedSet() const;
89 bool isWrappedSet(bool isSigned) const;
8290
8391 /// contains - Return true if the specified value is in the set.
92 /// The isSigned parameter indicates whether the comparisons should be
93 /// performed as if the values are signed or not.
8494 ///
85 bool contains(ConstantInt *Val) const;
95 bool contains(ConstantInt *Val, bool isSigned) const;
8696
8797 /// getSingleElement - If this set contains a single element, return it,
8898 /// otherwise return null.
116126 /// one of the sets but not the other. For example: [100, 8) intersect [3,
117127 /// 120) yields [3, 120)
118128 ///
119 ConstantRange intersectWith(const ConstantRange &CR) const;
129 ConstantRange intersectWith(const ConstantRange &CR, bool isSigned) const;
120130
121131 /// union - Return the range that results from the union of this range with
122132 /// another range. The resultant range is guaranteed to include the elements
124134 /// [3, 15), which includes 9, 10, and 11, which were not included in either
125135 /// set before.
126136 ///
127 ConstantRange unionWith(const ConstantRange &CR) const;
137 ConstantRange unionWith(const ConstantRange &CR, bool isSigned) const;
128138
129139 /// zeroExtend - Return a new range in the specified integer type, which must
130140 /// be strictly larger than the current type. The returned range will
166166 RetTy visitInvokeInst(InvokeInst &I) { DELEGATE(TerminatorInst);}
167167 RetTy visitUnwindInst(UnwindInst &I) { DELEGATE(TerminatorInst);}
168168 RetTy visitUnreachableInst(UnreachableInst &I) { DELEGATE(TerminatorInst);}
169 RetTy visitSetCondInst(SetCondInst &I) { DELEGATE(BinaryOperator);}
170169 RetTy visitICmpInst(ICmpInst &I) { DELEGATE(CmpInst);}
171170 RetTy visitFCmpInst(FCmpInst &I) { DELEGATE(CmpInst);}
172171 RetTy visitMallocInst(MallocInst &I) { DELEGATE(AllocationInst);}
247247 };
248248
249249 template
250 inline BinaryOpClass_match
251 m_SetCond(Instruction::BinaryOps &Op, const LHS &L, const RHS &R) {
252 return BinaryOpClass_match
253 SetCondInst, Instruction::BinaryOps>(Op, L, R);
254 }
255
256 template
257250 inline BinaryOpClass_match
258251 m_Shift(Instruction::OtherOps &Op, const LHS &L, const RHS &R) {
259252 return BinaryOpClass_match
266259 Instruction::OtherOps Op;
267260 return BinaryOpClass_match
268261 ShiftInst, Instruction::OtherOps>(Op, L, R);
262 }
263
264 //===----------------------------------------------------------------------===//
265 // Matchers for CmpInst classes
266 //
267
268 template
269 struct CmpClass_match {
270 PredicateTy &Predicate;
271 LHS_t L;
272 RHS_t R;
273
274 CmpClass_match(PredicateTy &Pred, const LHS_t &LHS,
275 const RHS_t &RHS)
276 : Predicate(Pred), L(LHS), R(RHS) {}
277
278 template
279 bool match(OpTy *V) {
280 if (Class *I = dyn_cast(V))
281 if (L.match(I->getOperand(0)) && R.match(I->getOperand(1))) {
282 Predicate = I->getPredicate();
283 return true;
284 }
285 return false;
286 }
287 };
288
289 template
290 inline CmpClass_match
291 m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
292 return CmpClass_match
293 ICmpInst, ICmpInst::Predicate>(Pred, L, R);
294 }
295
296 template
297 inline CmpClass_match
298 m_FCmp(FCmpInst::Predicate &Pred, const LHS &L, const RHS &R) {
299 return CmpClass_match
300 FCmpInst, FCmpInst::Predicate>(Pred, L, R);
269301 }
270302
271303 //===----------------------------------------------------------------------===//
4848 Constant *ConstantFoldInstruction(Instruction *I);
4949
5050 /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
51 /// specified opcode and operands. If successful, the constant result is
52 /// returned, if not, null is returned. Note that this function can fail when
53 /// attempting to fold instructions like loads and stores, which have no
54 /// constant expression form.
51 /// specified operands. If successful, the constant result is returned, if not,
52 /// null is returned. Note that this function can fail when attempting to
53 /// fold instructions like loads and stores, which have no constant expression
54 /// form.
5555 ///
56 Constant *ConstantFoldInstOperands(unsigned Opc, const Type *DestTy,
57 const std::vector &Ops);
56 Constant *ConstantFoldInstOperands(
57 const Instruction *I, ///< The model instruction
58 const std::vector &Ops ///< The constant operands to use.
59 );
5860
5961
6062 /// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a
589589 // Make sure they are comparable (ie, not constant expressions), and
590590 // make sure the GEP with the smaller leading constant is GEP1.
591591 if (G1OC) {
592 Constant *Compare = ConstantExpr::getSetGT(G1OC, G2OC);
592 Constant *Compare = ConstantExpr::getICmp(ICmpInst::ICMP_SGT,
593 G1OC, G2OC);
593594 if (ConstantBool *CV = dyn_cast(Compare)) {
594595 if (CV->getValue()) // If they are comparable and G2 > G1
595596 std::swap(GEP1Ops, GEP2Ops); // Make GEP1 < GEP2
2323 #include "llvm/Support/ConstantRange.h"
2424 #include "llvm/Constants.h"
2525 #include "llvm/Instruction.h"
26 #include "llvm/Instructions.h"
2627 #include "llvm/Type.h"
2728 #include "llvm/Support/Streams.h"
2829 #include
2930 using namespace llvm;
3031
31 static ConstantIntegral *getMaxValue(const Type *Ty) {
32 switch (Ty->getTypeID()) {
33 case Type::BoolTyID: return ConstantBool::getTrue();
34 case Type::SByteTyID:
35 case Type::ShortTyID:
36 case Type::IntTyID:
37 case Type::LongTyID: {
38 // Calculate 011111111111111...
39 unsigned TypeBits = Ty->getPrimitiveSize()*8;
40 int64_t Val = INT64_MAX; // All ones
41 Val >>= 64-TypeBits; // Shift out unwanted 1 bits...
42 return ConstantInt::get(Ty, Val);
43 }
44
45 case Type::UByteTyID:
46 case Type::UShortTyID:
47 case Type::UIntTyID:
48 case Type::ULongTyID: return ConstantInt::getAllOnesValue(Ty);
49
50 default: return 0;
51 }
32 static ConstantIntegral *getMaxValue(const Type *Ty, bool isSigned = false) {
33 if (Ty == Type::BoolTy)
34 return ConstantBool::getTrue();
35 if (Ty->isInteger()) {
36 if (isSigned) {
37 // Calculate 011111111111111...
38 unsigned TypeBits = Ty->getPrimitiveSize()*8;
39 int64_t Val = INT64_MAX; // All ones
40 Val >>= 64-TypeBits; // Shift out unwanted 1 bits...
41 return ConstantInt::get(Ty, Val);
42 }
43 return ConstantInt::getAllOnesValue(Ty);
44 }
45 return 0;
5246 }
5347
5448 // Static constructor to create the minimum constant for an integral type...
55 static ConstantIntegral *getMinValue(const Type *Ty) {
56 switch (Ty->getTypeID()) {
57 case Type::BoolTyID: return ConstantBool::getFalse();
58 case Type::SByteTyID:
59 case Type::ShortTyID:
60 case Type::IntTyID:
61 case Type::LongTyID: {
62 // Calculate 1111111111000000000000
63 unsigned TypeBits = Ty->getPrimitiveSize()*8;
64 int64_t Val = -1; // All ones
65 Val <<= TypeBits-1; // Shift over to the right spot
66 return ConstantInt::get(Ty, Val);
67 }
68
69 case Type::UByteTyID:
70 case Type::UShortTyID:
71 case Type::UIntTyID:
72 case Type::ULongTyID: return ConstantInt::get(Ty, 0);
73
74 default: return 0;
75 }
49 static ConstantIntegral *getMinValue(const Type *Ty, bool isSigned = false) {
50 if (Ty == Type::BoolTy)
51 return ConstantBool::getFalse();
52 if (Ty->isInteger()) {
53 if (isSigned) {
54 // Calculate 1111111111000000000000
55 unsigned TypeBits = Ty->getPrimitiveSize()*8;
56 int64_t Val = -1; // All ones
57 Val <<= TypeBits-1; // Shift over to the right spot
58 return ConstantInt::get(Ty, Val);
59 }
60 return ConstantInt::get(Ty, 0);
61 }
62 return 0;
7663 }
7764 static ConstantIntegral *Next(ConstantIntegral *CI) {
7865 if (ConstantBool *CB = dyn_cast(CI))
8370 return cast(Result);
8471 }
8572
86 static bool LT(ConstantIntegral *A, ConstantIntegral *B) {
87 Constant *C = ConstantExpr::getSetLT(A, B);
73 static bool LT(ConstantIntegral *A, ConstantIntegral *B, bool isSigned) {
74 Constant *C = ConstantExpr::getICmp(
75 (isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT), A, B);
8876 assert(isa(C) && "Constant folding of integrals not impl??");
8977 return cast(C)->getValue();
9078 }
9179
92 static bool LTE(ConstantIntegral *A, ConstantIntegral *B) {
93 Constant *C = ConstantExpr::getSetLE(A, B);
80 static bool LTE(ConstantIntegral *A, ConstantIntegral *B, bool isSigned) {
81 Constant *C = ConstantExpr::getICmp(
82 (isSigned ? ICmpInst::ICMP_SLE : ICmpInst::ICMP_ULE), A, B);
9483 assert(isa(C) && "Constant folding of integrals not impl??");
9584 return cast(C)->getValue();
9685 }
9786
98 static bool GT(ConstantIntegral *A, ConstantIntegral *B) { return LT(B, A); }
99
100 static ConstantIntegral *Min(ConstantIntegral *A, ConstantIntegral *B) {
101 return LT(A, B) ? A : B;
102 }
103 static ConstantIntegral *Max(ConstantIntegral *A, ConstantIntegral *B) {
104 return GT(A, B) ? A : B;
87 static bool GT(ConstantIntegral *A, ConstantIntegral *B, bool isSigned) {
88 return LT(B, A, isSigned); }
89
90 static ConstantIntegral *Min(ConstantIntegral *A, ConstantIntegral *B,
91 bool isSigned) {
92 return LT(A, B, isSigned) ? A : B;
93 }
94 static ConstantIntegral *Max(ConstantIntegral *A, ConstantIntegral *B,
95 bool isSigned) {
96 return GT(A, B, isSigned) ? A : B;
10597 }
10698
10799 /// Initialize a full (the default) or empty set for the specified type.
117109
118110 /// Initialize a range to hold the single specified value.
119111 ///
120 ConstantRange::ConstantRange(Constant *V)
121 : Lower(cast(V)), Upper(Next(cast(V))) {
122 }
112 ConstantRange::ConstantRange(Constant *V)
113 : Lower(cast(V)), Upper(Next(cast(V))) { }
123114
124115 /// Initialize a range of values explicitly... this will assert out if
125116 /// Lower==Upper and Lower != Min or Max for its type (or if the two constants
126117 /// have different types)
127118 ///
128 ConstantRange::ConstantRange(Constant *L, Constant *U)
119 ConstantRange::ConstantRange(Constant *L, Constant *U)
129120 : Lower(cast(L)), Upper(cast(U)) {
130121 assert(Lower->getType() == Upper->getType() &&
131122 "Incompatible types for ConstantRange!");
132123
133124 // Make sure that if L & U are equal that they are either Min or Max...
134125 assert((L != U || (L == getMaxValue(L->getType()) ||
135 L == getMinValue(L->getType()))) &&
136 "Lower == Upper, but they aren't min or max for type!");
126 L == getMinValue(L->getType())))
127 && "Lower == Upper, but they aren't min or max for type!");
137128 }
138129
139130 /// Initialize a set of values that all satisfy the condition with C.
140131 ///
141 ConstantRange::ConstantRange(unsigned SetCCOpcode, ConstantIntegral *C) {
142 switch (SetCCOpcode) {
143 default: assert(0 && "Invalid SetCC opcode to ConstantRange ctor!");
144 case Instruction::SetEQ: Lower = C; Upper = Next(C); return;
145 case Instruction::SetNE: Upper = C; Lower = Next(C); return;
146 case Instruction::SetLT:
132 ConstantRange::ConstantRange(unsigned short ICmpOpcode, ConstantIntegral *C) {
133 switch (ICmpOpcode) {
134 default: assert(0 && "Invalid ICmp opcode to ConstantRange ctor!");
135 case ICmpInst::ICMP_EQ: Lower = C; Upper = Next(C); return;
136 case ICmpInst::ICMP_NE: Upper = C; Lower = Next(C); return;
137 case ICmpInst::ICMP_ULT:
147138 Lower = getMinValue(C->getType());
148139 Upper = C;
149140 return;
150 case Instruction::SetGT:
141 case ICmpInst::ICMP_SLT:
142 Lower = getMinValue(C->getType(), true);
143 Upper = C;
144 return;
145 case ICmpInst::ICMP_UGT:
151146 Lower = Next(C);
152 Upper = getMinValue(C->getType()); // Min = Next(Max)
153 return;
154 case Instruction::SetLE:
147 Upper = getMinValue(C->getType()); // Min = Next(Max)
148 return;
149 case ICmpInst::ICMP_SGT:
150 Lower = Next(C);
151 Upper = getMinValue(C->getType(), true); // Min = Next(Max)
152 return;
153 case ICmpInst::ICMP_ULE:
155154 Lower = getMinValue(C->getType());
156155 Upper = Next(C);
157156 return;
158 case Instruction::SetGE:
157 case ICmpInst::ICMP_SLE:
158 Lower = getMinValue(C->getType(), true);
159 Upper = Next(C);
160 return;
161 case ICmpInst::ICMP_UGE:
159162 Lower = C;
160 Upper = getMinValue(C->getType()); // Min = Next(Max)
163 Upper = getMinValue(C->getType()); // Min = Next(Max)
164 return;
165 case ICmpInst::ICMP_SGE:
166 Lower = C;
167 Upper = getMinValue(C->getType(), true); // Min = Next(Max)
161168 return;
162169 }
163170 }
181188 /// isWrappedSet - Return true if this set wraps around the top of the range,
182189 /// for example: [100, 8)
183190 ///
184 bool ConstantRange::isWrappedSet() const {
185 return GT(Lower, Upper);
186 }
187
191 bool ConstantRange::isWrappedSet(bool isSigned) const {
192 return GT(Lower, Upper, isSigned);
193 }
188194
189195 /// getSingleElement - If this set contains a single element, return it,
190196 /// otherwise return null.
211217
212218 /// contains - Return true if the specified value is in the set.
213219 ///
214 bool ConstantRange::contains(ConstantInt *Val) const {
220 bool ConstantRange::contains(ConstantInt *Val, bool isSigned) const {
215221 if (Lower == Upper) {
216222 if (isFullSet()) return true;
217223 return false;
218224 }
219225
220 if (!isWrappedSet())
221 return LTE(Lower, Val) && LT(Val, Upper);
222 return LTE(Lower, Val) || LT(Val, Upper);
223 }
224
225
226 if (!isWrappedSet(isSigned))
227 return LTE(Lower, Val, isSigned) && LT(Val, Upper, isSigned);
228 return LTE(Lower, Val, isSigned) || LT(Val, Upper, isSigned);
229 }
226230
227231 /// subtract - Subtract the specified constant from the endpoints of this
228232 /// constant range.
240244 // it is known that LHS is wrapped and RHS isn't.
241245 //
242246 static ConstantRange intersect1Wrapped(const ConstantRange &LHS,
243 const ConstantRange &RHS) {
244 assert(LHS.isWrappedSet() && !RHS.isWrappedSet());
247 const ConstantRange &RHS,
248 bool isSigned) {
249 assert(LHS.isWrappedSet(isSigned) && !RHS.isWrappedSet(isSigned));
245250
246251 // Check to see if we overlap on the Left side of RHS...
247252 //
248 if (LT(RHS.getLower(), LHS.getUpper())) {
253 if (LT(RHS.getLower(), LHS.getUpper(), isSigned)) {
249254 // We do overlap on the left side of RHS, see if we overlap on the right of
250255 // RHS...
251 if (GT(RHS.getUpper(), LHS.getLower())) {
256 if (GT(RHS.getUpper(), LHS.getLower(), isSigned)) {
252257 // Ok, the result overlaps on both the left and right sides. See if the
253258 // resultant interval will be smaller if we wrap or not...
254259 //
261266 // No overlap on the right, just on the left.
262267 return ConstantRange(RHS.getLower(), LHS.getUpper());
263268 }
264
265269 } else {
266270 // We don't overlap on the left side of RHS, see if we overlap on the right
267271 // of RHS...
268 if (GT(RHS.getUpper(), LHS.getLower())) {
272 if (GT(RHS.getUpper(), LHS.getLower(), isSigned)) {
269273 // Simple overlap...
270274 return ConstantRange(LHS.getLower(), RHS.getUpper());
271275 } else {
278282 /// intersect - Return the range that results from the intersection of this
279283 /// range with another range.
280284 ///
281 ConstantRange ConstantRange::intersectWith(const ConstantRange &CR) const {
285 ConstantRange ConstantRange::intersectWith(const ConstantRange &CR,
286 bool isSigned) const {
282287 assert(getType() == CR.getType() && "ConstantRange types don't agree!");
283288 // Handle common special cases
284289 if (isEmptySet() || CR.isFullSet()) return *this;
285290 if (isFullSet() || CR.isEmptySet()) return CR;
286291
287 if (!isWrappedSet()) {
288 if (!CR.isWrappedSet()) {
289 ConstantIntegral *L = Max(Lower, CR.Lower);
290 ConstantIntegral *U = Min(Upper, CR.Upper);
291
292 if (LT(L, U)) // If range isn't empty...
292 if (!isWrappedSet(isSigned)) {
293 if (!CR.isWrappedSet(isSigned)) {
294 ConstantIntegral *L = Max(Lower, CR.Lower, isSigned);
295 ConstantIntegral *U = Min(Upper, CR.Upper, isSigned);
296
297 if (LT(L, U, isSigned)) // If range isn't empty...
293298 return ConstantRange(L, U);
294299 else
295300 return ConstantRange(getType(), false); // Otherwise, return empty set
296301 } else
297 return intersect1Wrapped(CR, *this);
302 return intersect1Wrapped(CR, *this, isSigned);
298303 } else { // We know "this" is wrapped...
299 if (!CR.isWrappedSet())
300 return intersect1Wrapped(*this, CR);
304 if (!CR.isWrappedSet(isSigned))
305 return intersect1Wrapped(*this, CR, isSigned);
301306 else {
302307 // Both ranges are wrapped...
303 ConstantIntegral *L = Max(Lower, CR.Lower);
304 ConstantIntegral *U = Min(Upper, CR.Upper);
308 ConstantIntegral *L = Max(Lower, CR.Lower, isSigned);
309 ConstantIntegral *U = Min(Upper, CR.Upper, isSigned);
305310 return ConstantRange(L, U);
306311 }
307312 }
314319 /// 15), which includes 9, 10, and 11, which were not included in either set
315320 /// before.
316321 ///
317 ConstantRange ConstantRange::unionWith(const ConstantRange &CR) const {
322 ConstantRange ConstantRange::unionWith(const ConstantRange &CR,
323 bool isSigned) const {
318324 assert(getType() == CR.getType() && "ConstantRange types don't agree!");
319325
320326 assert(0 && "Range union not implemented yet!");
324330
325331 /// zeroExtend - Return a new range in the specified integer type, which must
326332 /// be strictly larger than the current type. The returned range will
327 /// correspond to the possible range of values if the source range had been
333 /// correspond to the possible range of values as if the source range had been
328334 /// zero extended.
329335 ConstantRange ConstantRange::zeroExtend(const Type *Ty) const {
330336 assert(getLower()->getType()->getPrimitiveSize() < Ty->getPrimitiveSize() &&
345351
346352 /// truncate - Return a new range in the specified integer type, which must be
347353 /// strictly smaller than the current type. The returned range will
348 /// correspond to the possible range of values if the source range had been
354 /// correspond to the possible range of values as if the source range had been
349355 /// truncated to the specified type.
350356 ConstantRange ConstantRange::truncate(const Type *Ty) const {
351357 assert(getLower()->getType()->getPrimitiveSize() > Ty->getPrimitiveSize() &&
359365 ConstantExpr::getTrunc(getUpper(), Ty));
360366 }
361367
362
363368 /// print - Print out the bounds to a stream...
364369 ///
365370 void ConstantRange::print(std::ostream &OS) const {
324324 void visitGetElementPtrInst(GetElementPtrInst &GEP);
325325 void visitPHINode(PHINode &PN);
326326 void visitCastInst(CastInst &CI);
327 void visitSetCondInst(SetCondInst &SCI) {} // NOOP!
327 void visitICmpInst(ICmpInst &ICI) {} // NOOP!
328 void visitFCmpInst(FCmpInst &ICI) {} // NOOP!
328329 void visitSelectInst(SelectInst &SI);
329330 void visitVAArg(VAArgInst &I);
330331 void visitInstruction(Instruction &I);
777778 case Instruction::Shl:
778779 case Instruction::LShr:
779780 case Instruction::AShr:
781 case Instruction::ICmp:
782 case Instruction::FCmp:
780783 return;
781784 default:
782785 // Is this something we aren't handling yet?
250250 } else {
251251 return true;
252252 }
253 } else if (SetCondInst *SCI = dyn_cast(*UI)) {
254 if (!isa(SCI->getOperand(1)))
253 } else if (ICmpInst *ICI = dyn_cast(*UI)) {
254 if (!isa(ICI->getOperand(1)))
255255 return true; // Allow comparison against null.
256256 } else if (FreeInst *F = dyn_cast(*UI)) {
257257 Writers.push_back(F->getParent()->getParent());
535535 /// returns null.
536536 ///
537537 Value *Loop::getTripCount() const {
538 // Canonical loops will end with a 'setne I, V', where I is the incremented
538 // Canonical loops will end with a 'cmp ne I, V', where I is the incremented
539539 // canonical induction variable and V is the trip count of the loop.
540540 Instruction *Inc = getCanonicalInductionVariableIncrement();
541541 if (Inc == 0) return 0;
545545 IV->getIncomingBlock(contains(IV->getIncomingBlock(1)));
546546
547547 if (BranchInst *BI = dyn_cast(BackedgeBlock->getTerminator()))
548 if (BI->isConditional())
549 if (SetCondInst *SCI = dyn_cast(BI->getCondition()))
550 if (SCI->getOperand(0) == Inc)
548 if (BI->isConditional()) {
549 if (ICmpInst *ICI = dyn_cast(BI->getCondition())) {
550 if (ICI->getOperand(0) == Inc)
551551 if (BI->getSuccessor(0) == getHeader()) {
552 if (SCI->getOpcode() == Instruction::SetNE)
553 return SCI->getOperand(1);
554 } else if (SCI->getOpcode() == Instruction::SetEQ) {
555 return SCI->getOperand(1);
552 if (ICI->getPredicate() == ICmpInst::ICMP_NE)
553 return ICI->getOperand(1);
554 } else if (ICI->getPredicate() == ICmpInst::ICMP_EQ) {
555 return ICI->getOperand(1);
556556 }
557 }
558 }
557559
558560 return 0;
559561 }
176176 // are signless. There won't be a need to bitcast then.
177177 if (V->getType()->isSigned()) {
178178 const Type *NewTy = V->getType()->getUnsignedVersion();
179 V = cast(
180 ConstantExpr::getBitCast(V, NewTy));
179 V = cast(ConstantExpr::getBitCast(V, NewTy));
181180 }
182181
183182 SCEVConstant *&R = (*SCEVConstants)[V];
460459 C = Constant::getNullValue(Ty);
461460 else if (Ty->isFloatingPoint())
462461 C = ConstantFP::get(Ty, Val);
463 /// FIXME:Signless. when integer types are signless, just change this to:
464 /// else
465 /// C = ConstantInt::get(Ty, Val);
466 else if (Ty->isSigned())
462 else
467463 C = ConstantInt::get(Ty, Val);
468 else {
469 C = ConstantInt::get(Ty->getSignedVersion(), Val);
470 C = ConstantExpr::getBitCast(C, Ty);
471 }
472464 return SCEVUnknown::get(C);
473465 }
474466
513505 for (; NumSteps; --NumSteps)
514506 Result *= Val-(NumSteps-1);
515507 Constant *Res = ConstantInt::get(Type::ULongTy, Result);
516 return SCEVUnknown::get(
517 ConstantExpr::getTruncOrBitCast(Res, V->getType()));
508 return SCEVUnknown::get(ConstantExpr::getTruncOrBitCast(Res, V->getType()));
518509 }
519510
520511 const Type *Ty = V->getType();
11611152 SCEVHandle ComputeLoadConstantCompareIterationCount(LoadInst *LI,
11621153 Constant *RHS,
11631154 const Loop *L,
1164 unsigned SetCCOpcode);
1155 ICmpInst::Predicate p);
11651156
11661157 /// ComputeIterationCountExhaustively - If the trip is known to execute a
11671158 /// constant number of times (the condition evolves only from constants),
15201511 BranchInst *ExitBr = dyn_cast(ExitingBlock->getTerminator());
15211512 if (ExitBr == 0) return UnknownValue;
15221513 assert(ExitBr->isConditional() && "If unconditional, it can't be in loop!");
1523 SetCondInst *ExitCond = dyn_cast(ExitBr->getCondition());
1524 if (ExitCond == 0) // Not a setcc
1514 ICmpInst *ExitCond = dyn_cast(ExitBr->getCondition());
1515
1516 // If its not an integer comparison then compute it the hard way.
1517 // Note that ICmpInst deals with pointer comparisons too so we must check
1518 // the type of the operand.
1519 if (ExitCond == 0 || !ExitCond->getOperand(0)->getType()->isIntegral())
15251520 return ComputeIterationCountExhaustively(L, ExitBr->getCondition(),
15261521 ExitBr->getSuccessor(0) == ExitBlock);
15271522
1528 // If the condition was exit on true, convert the condition to exit on false.
1529 Instruction::BinaryOps Cond;
1523 // If the condition was exit on true, convert the condition to exit on false
1524 ICmpInst::Predicate Cond;
15301525 if (ExitBr->getSuccessor(1) == ExitBlock)
1531 Cond = ExitCond->getOpcode();
1526 Cond = ExitCond->getPredicate();
15321527 else
1533 Cond = ExitCond->getInverseCondition();
1528 Cond = ExitCond->getInversePredicate();
15341529
15351530 // Handle common loops like: for (X = "string"; *X; ++X)
15361531 if (LoadInst *LI = dyn_cast(ExitCond->getOperand(0)))
15491544 Tmp = getSCEVAtScope(RHS, L);
15501545 if (!isa(Tmp)) RHS = Tmp;
15511546
1552 // At this point, we would like to compute how many iterations of the loop the
1553 // predicate will return true for these inputs.
1547 // At this point, we would like to compute how many iterations of the
1548 // loop the predicate will return true for these inputs.
15541549 if (isa(LHS) && !isa(RHS)) {
15551550 // If there is a constant, force it into the RHS.
15561551 std::swap(LHS, RHS);
1557 Cond = SetCondInst::getSwappedCondition(Cond);
1552 Cond = ICmpInst::getSwappedPredicate(Cond);
15581553 }
15591554
15601555 // FIXME: think about handling pointer comparisons! i.e.:
15891584 CompRange = ConstantRange(NewL, NewU);
15901585 }
15911586
1592 SCEVHandle Ret = AddRec->getNumIterationsInRange(CompRange);
1587 SCEVHandle Ret = AddRec->getNumIterationsInRange(CompRange,
1588 ICmpInst::isSignedPredicate(Cond));
15931589 if (!isa(Ret)) return Ret;
15941590 }
15951591 }
15961592
15971593 switch (Cond) {
1598 case Instruction::SetNE: // while (X != Y)
1594 case ICmpInst::ICMP_NE: { // while (X != Y)
15991595 // Convert to: while (X-Y != 0)
1600 if (LHS->getType()->isInteger()) {
1601 SCEVHandle TC = HowFarToZero(SCEV::getMinusSCEV(LHS, RHS), L);
1602 if (!isa(TC)) return TC;
1603 }
1596 SCEVHandle TC = HowFarToZero(SCEV::getMinusSCEV(LHS, RHS), L);
1597 if (!isa(TC)) return TC;
16041598 break;
1605 case Instruction::SetEQ:
1599 }
1600 case ICmpInst::ICMP_EQ: {
16061601 // Convert to: while (X-Y == 0) // while (X == Y)
1607 if (LHS->getType()->isInteger()) {
1608 SCEVHandle TC = HowFarToNonZero(SCEV::getMinusSCEV(LHS, RHS), L);
1609 if (!isa(TC)) return TC;
1610 }
1602 SCEVHandle TC = HowFarToNonZero(SCEV::getMinusSCEV(LHS, RHS), L);
1603 if (!isa(TC)) return TC;
16111604 break;
1612 case Instruction::SetLT:
1613 if (LHS->getType()->isInteger() &&
1614 ExitCond->getOperand(0)->getType()->isSigned()) {
1615 SCEVHandle TC = HowManyLessThans(LHS, RHS, L);
1616 if (!isa(TC)) return TC;
1617 }
1605 }
1606 case ICmpInst::ICMP_SLT: {
1607 SCEVHandle TC = HowManyLessThans(LHS, RHS, L);
1608 if (!isa(TC)) return TC;
16181609 break;
1619 case Instruction::SetGT:
1620 if (LHS->getType()->isInteger() &&
1621 ExitCond->getOperand(0)->getType()->isSigned()) {
1622 SCEVHandle TC = HowManyLessThans(RHS, LHS, L);
1623 if (!isa(TC)) return TC;
1624 }
1610 }
1611 case ICmpInst::ICMP_SGT: {
1612 SCEVHandle TC = HowManyLessThans(RHS, LHS, L);
1613 if (!isa(TC)) return TC;
16251614 break;
1615 }
16261616 default:
16271617 #if 0
16281618 cerr << "ComputeIterationCount ";
16291619 if (ExitCond->getOperand(0)->getType()->isUnsigned())
16301620 cerr << "[unsigned] ";
16311621 cerr << *LHS << " "
1632 << Instruction::getOpcodeName(Cond) << " " << *RHS << "\n";
1622 << Instruction::getOpcodeName(Instruction::ICmp)
1623 << " " << *RHS << "\n";
16331624 #endif
16341625 break;
16351626 }
1636
16371627 return ComputeIterationCountExhaustively(L, ExitCond,
1638 ExitBr->getSuccessor(0) == ExitBlock);
1628 ExitBr->getSuccessor(0) == ExitBlock);
16391629 }
16401630
16411631 static ConstantInt *
16851675 /// 'setcc load X, cst', try to se if we can compute the trip count.
16861676 SCEVHandle ScalarEvolutionsImpl::
16871677 ComputeLoadConstantCompareIterationCount(LoadInst *LI, Constant *RHS,
1688 const Loop *L, unsigned SetCCOpcode) {
1678 const Loop *L,
1679 ICmpInst::Predicate predicate) {
16891680 if (LI->isVolatile()) return UnknownValue;
16901681
16911682 // Check to see if the loaded pointer is a getelementptr of a global.
17411732 if (Result == 0) break; // Cannot compute!
17421733
17431734 // Evaluate the condition for this iteration.
1744 Result = ConstantExpr::get(SetCCOpcode, Result, RHS);
1735 Result = ConstantExpr::getICmp(predicate, Result, RHS);
17451736 if (!isa(Result)) break; // Couldn't decide for sure
17461737 if (cast(Result)->getValue() == false) {
17471738 #if 0
17601751 /// CanConstantFold - Return true if we can constant fold an instruction of the
17611752 /// specified type, assuming that all operands were constants.
17621753 static bool CanConstantFold(const Instruction *I) {
1763 if (isa(I) || isa(I) ||
1754 if (isa(I) || isa(I) || isa(I) ||
17641755 isa(I) || isa(I) || isa(I))
17651756 return true;
17661757
17891780 return ConstantFoldCall(cast(GV), Operands);
17901781 }
17911782 return 0;
1792 case Instruction::GetElementPtr:
1783 case Instruction::GetElementPtr: {
17931784 Constant *Base = Operands[0];
17941785 Operands.erase(Operands.begin());
17951786 return ConstantExpr::getGetElementPtr(Base, Operands);
1787 }
1788 case Instruction::ICmp:
1789 return ConstantExpr::getICmp(
1790 cast(I)->getPredicate(), Operands[0], Operands[1]);
1791 case Instruction::FCmp:
1792 return ConstantExpr::getFCmp(
1793 cast(I)->getPredicate(), Operands[0], Operands[1]);
17961794 }
17971795 return 0;
17981796 }
22252223 // Pick the smallest positive root value.
22262224 assert(R1->getType()->isUnsigned()&&"Didn't canonicalize to unsigned?");
22272225 if (ConstantBool *CB =
2228 dyn_cast(ConstantExpr::getSetLT(R1->getValue(),
2229 R2->getValue()))) {
2226 dyn_cast(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
2227 R1->getValue(), R2->getValue()))) {
22302228 if (CB->getValue() == false)
22312229 std::swap(R1, R2); // R1 is the minimum root now.
22322230
22562254 // already. If so, the backedge will execute zero times.
22572255 if (SCEVConstant *C = dyn_cast(V)) {
22582256 Constant *Zero = Constant::getNullValue(C->getValue()->getType());
2259 Constant *NonZero = ConstantExpr::getSetNE(C->getValue(), Zero);
2257 Constant *NonZero =
2258 ConstantExpr::getICmp(ICmpInst::ICMP_NE, C->getValue(), Zero);
22602259 if (NonZero == ConstantBool::getTrue())
22612260 return getSCEV(Zero);
22622261 return UnknownValue; // Otherwise it will loop infinitely.
23172316
23182317 // Now that we found a conditional branch that dominates the loop, check to
23192318 // see if it is the comparison we are looking for.
2320 SetCondInst *SCI =dyn_cast(LoopEntryPredicate->getCondition());
2321 if (!SCI) return UnknownValue;
2322 Value *PreCondLHS = SCI->getOperand(0);
2323 Value *PreCondRHS = SCI->getOperand(1);
2324 Instruction::BinaryOps Cond;
2325 if (LoopEntryPredicate->getSuccessor(0) == PreheaderDest)
2326 Cond = SCI->getOpcode();
2327 else
2328 Cond = SCI->getInverseCondition();
2319 if (ICmpInst *ICI = dyn_cast(LoopEntryPredicate->getCondition())){
2320 Value *PreCondLHS = ICI->getOperand(0);
2321 Value *PreCondRHS = ICI->getOperand(1);
2322 ICmpInst::Predicate Cond;
2323 if (LoopEntryPredicate->getSuccessor(0) == PreheaderDest)
2324 Cond = ICI->getPredicate();
2325 else
2326 Cond = ICI->getInversePredicate();
23292327
2330 switch (Cond) {
2331 case Instruction::SetGT:
2332 std::swap(PreCondLHS, PreCondRHS);
2333 Cond = Instruction::SetLT;
2334 // Fall Through.
2335 case Instruction::SetLT:
2336 if (PreCondLHS->getType()->isInteger() &&
2337 PreCondLHS->getType()->isSigned()) {
2338 if (RHS != getSCEV(PreCondRHS))
2339 return UnknownValue; // Not a comparison against 'm'.
2340
2341 if (SCEV::getMinusSCEV(AddRec->getOperand(0), One)
2342 != getSCEV(PreCondLHS))
2343 return UnknownValue; // Not a comparison against 'n-1'.
2328 switch (Cond) {
2329 case ICmpInst::ICMP_UGT:
2330 std::swap(PreCondLHS, PreCondRHS);
2331 Cond = ICmpInst::ICMP_ULT;
23442332 break;
2345 } else {
2333 case ICmpInst::ICMP_SGT:
2334 std::swap(PreCondLHS, PreCondRHS);
2335 Cond = ICmpInst::ICMP_SLT;
2336 break;
2337 default: break;
2338 }
2339
2340 if (Cond == ICmpInst::ICMP_SLT) {
2341 if (PreCondLHS->getType()->isInteger()) {
2342 if (RHS != getSCEV(PreCondRHS))
2343 return UnknownValue; // Not a comparison against 'm'.
2344
2345 if (SCEV::getMinusSCEV(AddRec->getOperand(0), One)
2346 != getSCEV(PreCondLHS))
2347 return UnknownValue; // Not a comparison against 'n-1'.
2348 }
2349 else return UnknownValue;
2350 } else if (Cond == ICmpInst::ICMP_ULT)
23462351 return UnknownValue;
2347 }
2348 default: break;
2349 }
2350
2351 //cerr << "Computed Loop Trip Count as: "
2352 // << *SCEV::getMinusSCEV(RHS, AddRec->getOperand(0)) << "\n";
2353 return SCEV::getMinusSCEV(RHS, AddRec->getOperand(0));
2352
2353 // cerr << "Computed Loop Trip Count as: "
2354 // << // *SCEV::getMinusSCEV(RHS, AddRec->getOperand(0)) << "\n";
2355 return SCEV::getMinusSCEV(RHS, AddRec->getOperand(0));
2356 }
2357 else
2358 return UnknownValue;
23542359 }
23552360
23562361 return UnknownValue;
23612366 /// this is that it returns the first iteration number where the value is not in
23622367 /// the condition, thus computing the exit count. If the iteration count can't
23632368 /// be computed, an instance of SCEVCouldNotCompute is returned.
2364 SCEVHandle SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range) const {
2369 SCEVHandle SCEVAddRecExpr::getNumIterationsInRange(ConstantRange Range,
2370 bool isSigned) const {
23652371 if (Range.isFullSet()) // Infinite loop.
23662372 return new SCEVCouldNotCompute();
23672373
23732379 SCEVHandle Shifted = SCEVAddRecExpr::get(Operands, getLoop());
23742380 if (SCEVAddRecExpr *ShiftedAddRec = dyn_cast(Shifted))
23752381 return ShiftedAddRec->getNumIterationsInRange(
2376 Range.subtract(SC->getValue()));
2382 Range.subtract(SC->getValue()),isSigned);
23772383 // This is strange and shouldn't happen.
23782384 return new SCEVCouldNotCompute();
23792385 }
23912397 // First check to see if the range contains zero. If not, the first
23922398 // iteration exits.
23932399 ConstantInt *Zero = ConstantInt::get(getType(), 0);
2394 if (!Range.contains(Zero)) return SCEVConstant::get(Zero);
2400 if (!Range.contains(Zero, isSigned)) return SCEVConstant::get(Zero);
23952401
23962402 if (isAffine()) {
23972403 // If this is an affine expression then we have this situation:
24172423 // range, then we computed our trip count, otherwise wrap around or other
24182424 // things must have happened.
24192425 ConstantInt *Val = EvaluateConstantChrecAtConstant(this, ExitValue);
2420 if (Range.contains(Val))
2426 if (Range.contains(Val, isSigned))
24212427 return new SCEVCouldNotCompute(); // Something strange happened
24222428
24232429 // Ensure that the previous value is in the range. This is a sanity check.
24242430 assert(Range.contains(EvaluateConstantChrecAtConstant(this,
2425 ConstantExpr::getSub(ExitValue, One))) &&
2431 ConstantExpr::getSub(ExitValue, One)), isSigned) &&
24262432 "Linear scev computation is off in a bad way!");
24272433 return SCEVConstant::get(cast(ExitValue));
24282434 } else if (isQuadratic()) {
24432449 // Pick the smallest positive root value.
24442450 assert(R1->getType()->isUnsigned() && "Didn't canonicalize to unsigned?");
24452451 if (ConstantBool *CB =
2446 dyn_cast(ConstantExpr::getSetLT(R1->getValue(),
2447 R2->getValue()))) {
2452 dyn_cast(ConstantExpr::getICmp(ICmpInst::ICMP_ULT,
2453 R1->getValue(), R2->getValue()))) {
24482454 if (CB->getValue() == false)
24492455 std::swap(R1, R2); // R1 is the minimum root now.
24502456
24532459 // for "X*X < 5", for example, we should not return a root of 2.
24542460 ConstantInt *R1Val = EvaluateConstantChrecAtConstant(this,
24552461 R1->getValue());
2456 if (Range.contains(R1Val)) {
2462 if (Range.contains(R1Val, isSigned)) {
24572463 // The next iteration must be out of the range...
24582464 Constant *NextVal =
24592465 ConstantExpr::getAdd(R1->getValue(),
24602466 ConstantInt::get(R1->getType(), 1));
24612467
24622468 R1Val = EvaluateConstantChrecAtConstant(this, NextVal);
2463 if (!Range.contains(R1Val))
2469 if (!Range.contains(R1Val, isSigned))
24642470 return SCEVUnknown::get(NextVal);
24652471 return new SCEVCouldNotCompute(); // Something strange happened
24662472 }
24712477 ConstantExpr::getSub(R1->getValue(),
24722478 ConstantInt::get(R1->getType(), 1));
24732479 R1Val = EvaluateConstantChrecAtConstant(this, NextVal);
2474 if (Range.contains(R1Val))
2480 if (Range.contains(R1Val, isSigned))
24752481 return R1;
24762482 return new SCEVCouldNotCompute(); // Something strange happened
24772483 }
24932499 return new SCEVCouldNotCompute();
24942500
24952501 // Check to see if we found the value!
2496 if (!Range.contains(cast(Val)->getValue()))
2502 if (!Range.contains(cast(Val)->getValue(), isSigned))
24972503 return SCEVConstant::get(TestVal);
24982504
24992505 // Increment to test the next index.
160160 I1.getParent()->getParent() != I2->getParent()->getParent())
161161 return false;
162162
163 // If they are CmpInst instructions, check their predicates
164 if (CmpInst *CI1 = dyn_cast(&const_cast(I1)))
165 if (CI1->getPredicate() != cast(I2)->getPredicate())
166 return false;
167
163168 // They are identical if both operands are the same!
164169 if (I1.getOperand(0) == I2->getOperand(0) &&
165170 I1.getOperand(1) == I2->getOperand(1))
316316 *yy_cp = '\0'; \
317317 yy_c_buf_p = yy_cp;
318318
319 #define YY_NUM_RULES 147
320 #define YY_END_OF_BUFFER 148
321 static yyconst short int yy_acclist[225] =
319 #define YY_NUM_RULES 141
320 #define YY_END_OF_BUFFER 142
321 static yyconst short int yy_acclist[219] =
322322 { 0,
323 148, 146, 147, 145, 146, 147, 145, 147, 146, 147,
324 146, 147, 146, 147, 146, 147, 146, 147, 146, 147,
325 138, 146, 147, 138, 146, 147, 1, 146, 147, 146,
326 147, 146, 147, 146, 147, 146, 147, 146, 147, 146,
327 147, 146, 147, 146, 147, 146, 147, 146, 147, 146,
328 147, 146, 147, 146, 147, 146, 147, 146, 147, 146,
329 147, 146, 147, 146, 147, 146, 147, 146, 147, 146,
330 147, 137, 135, 134, 134, 141, 139, 143, 138, 1,
331 120, 38, 80, 81, 70, 22, 137, 134, 134, 142,
332 143, 19, 143, 144, 60, 69, 36, 31, 39, 3,
333
334 51, 62, 90, 95, 93, 94, 92, 91, 96, 100,
335 119, 85, 83, 115, 84, 82, 61, 98, 89, 87,
336 88, 86, 99, 97, 71, 136, 143, 143, 117, 46,
337 101, 79, 65, 127, 68, 78, 128, 53, 116, 21,
338 140, 64, 104, 67, 23, 4, 58, 63, 52, 66,
339 45, 11, 103, 143, 33, 2, 5, 55, 106, 57,
340 47, 73, 77, 75, 76, 74, 72, 49, 129, 102,
341 48, 54, 20, 126, 42, 56, 27, 41, 110, 109,
342 7, 122, 30, 125, 35, 59, 114, 108, 121, 24,
343 25, 107, 123, 50, 118, 113, 40, 6, 26, 105,
344
345 34, 8, 16, 9, 111, 10, 112, 32, 12, 14,
346 13, 29, 37, 15, 28, 124, 130, 132, 133, 43,
347 131, 17, 44, 18
323 142, 140, 141, 139, 140, 141, 139, 141, 140, 141,
324 140, 141, 140, 141, 140, 141, 140, 141, 140, 141,
325 132, 140, 141, 132, 140, 141, 1, 140, 141, 140,
326 141, 140, 141, 140, 141, 140, 141, 140, 141, 140,
327 141, 140, 141, 140, 141, 140, 141, 140, 141, 140,
328 141, 140, 141, 140, 141, 140, 141, 140, 141, 140,
329 141, 140, 141, 140, 141, 140, 141, 140, 141, 140,
330 141, 131, 129, 128, 128, 135, 133, 137, 132, 1,
331 114, 38, 74, 75, 70, 22, 131, 128, 128, 136,
332 137, 19, 137, 138, 60, 69, 36, 31, 39, 3,
333
334 51, 62, 84, 89, 87, 88, 86, 85, 90, 94,
335 113, 79, 77, 109, 78, 76, 61, 92, 83, 81,
336 82, 80, 93, 91, 71, 130, 137, 137, 111, 46,
337 95, 73, 65, 121, 68, 72, 122, 53, 110, 21,
338 134, 64, 98, 67, 23, 4, 58, 63, 52, 66,
339 45, 11, 97, 137, 33, 2, 5, 55, 100, 57,
340 47, 49, 123, 96, 48, 54, 20, 120, 42, 56,
341 27, 41, 104, 103, 7, 116, 30, 119, 35, 59,
342 108, 102, 115, 24, 25, 101, 117, 50, 112, 107,
343 40, 6, 26, 99, 34, 8, 16, 9, 105, 10,
344
345 106, 32, 12, 14, 13, 29, 37, 15, 28, 118,
346 124, 126, 127, 43, 125, 17, 44, 18
348347 } ;
349348
350 static yyconst short int yy_accept[581] =
349 static yyconst short int yy_accept[570] =
351350 { 0,
352351 1, 1, 1, 2, 4, 7, 9, 11, 13, 15,
353352 17, 19, 21, 24, 27, 30, 32, 34, 36, 38,
371370 102, 102, 102, 102, 102, 102, 103, 103, 104, 105,
372371 106, 107, 108, 109, 109, 110, 111, 111, 111, 112,
373372
374 112, 112, 112, 112, 112, 112, 112, 113, 114, 115,
375 115, 115, 115, 115, 116, 117, 117, 117, 118, 118,
376 118, 118, 118, 118, 118, 118, 118, 119, 120, 121,
377 121, 121, 122, 122, 123, 123, 124, 125, 125, 125,
378 125, 125, 125, 125, 125, 125, 125, 126, 126, 126,
379 127, 128, 128, 128, 128, 129, 129, 129, 129, 130,
380 130, 130, 131, 132, 132, 132, 132, 132, 132, 132,
381 132, 132, 132, 132, 132, 132, 132, 132, 133, 134,
382 134, 134, 134, 134, 135, 136, 136, 136, 137, 137,
383 137, 137, 137, 137, 137, 137, 137, 138, 139, 140,
384
385 140, 140, 141, 141, 141, 141, 142, 142, 143, 143,
386 143, 143, 143, 143, 143, 144, 144, 144, 144, 144,
387 145, 145, 145, 146, 146, 146, 147, 147, 148, 148,
388 149, 150, 150, 150, 150, 150, 150, 151, 151, 151,
389 152, 152, 153, 153, 153, 154, 155, 156, 156, 156,
390 157, 157, 157, 157, 157, 157, 157, 157, 157, 157,
391 157, 157, 157, 157, 158, 158, 159, 160, 160, 160,
392 160, 160, 160, 160, 160, 160, 160, 160, 161, 161,
393 161, 161, 161, 161, 161, 161, 162, 162, 162, 163,
394 164, 165, 166, 167, 168, 169, 169, 169, 169, 170,
395
396 170, 170, 170, 171, 172, 172, 173, 174, 174, 174,
397 174, 174, 174, 174, 174, 174, 175, 175, 175, 176,
398 176, 176, 176, 176, 176, 176, 176, 177, 178, 178,
399 178, 179, 180, 181, 181, 181, 182, 182, 182, 182,
400 182, 183, 183, 184, 185, 186, 187, 187, 187, 187,
401 188, 188, 188, 189, 190, 191, 192, 193, 193, 194,
402 195, 196, 196, 196, 196, 196, 196, 197, 197, 198,
403 198, 199, 200, 200, 200, 200, 200, 200, 201, 201,
404 201, 201, 201, 201, 201, 201, 201, 202, 202, 202,
405 202, 202, 202, 202, 202, 202, 203, 203, 203, 203,
406
407 203, 204, 204, 204, 204, 204, 205, 206, 207, 207,
408 208, 208, 208, 208, 209, 209, 209, 209, 210, 210,
409 211, 212, 212, 212, 212, 212, 212, 212, 212, 212,
410 212, 212, 212, 212, 213, 213, 213, 213, 213, 213,
411 213, 213, 214, 214, 214, 214, 214, 215, 215, 215,
412 215, 215, 216, 216, 217, 217, 217, 217, 217, 217,
413 217, 217, 217, 217, 217, 217, 217, 218, 218, 219,
414 220, 220, 221, 221, 222, 223, 224, 224, 225, 225
373 112, 112, 112, 112, 112, 112, 113, 114, 115, 115,
374 115, 115, 115, 116, 117, 117, 117, 118, 118, 118,
375 118, 118, 118, 118, 118, 118, 119, 120, 121, 121,
376 121, 122, 122, 123, 123, 124, 125, 125, 125, 125,
377 125, 125, 125, 125, 125, 125, 126, 126, 126, 127,
378 128, 128, 128, 128, 129, 129, 129, 129, 130, 130,
379 130, 131, 132, 132, 132, 132, 132, 132, 132, 132,
380 132, 132, 132, 132, 132, 132, 132, 133, 134, 134,
381 134, 134, 134, 135, 136, 136, 136, 137, 137, 137,
382 137, 137, 137, 137, 137, 137, 138, 139, 140, 140,
383
384 140, 141, 141, 141, 141, 142, 142, 143, 143, 143,
385 144, 144, 144, 144, 144, 145, 145, 145, 146, 146,
386 146, 147, 147, 148, 148, 149, 150, 150, 150, 150,
387 150, 150, 151, 151, 151, 152, 152, 153, 153, 153,
388 154, 155, 156, 156, 156, 157, 157, 157, 157, 157,
389 157, 157, 157, 157, 157, 157, 157, 157, 157, 158,
390 158, 159, 160, 160, 160, 160, 160, 160, 160, 160,
391 160, 160, 160, 161, 161, 161, 161, 161, 161, 161,
392 161, 162, 162, 162, 163, 163, 163, 163, 164, 164,
393 164, 164, 165, 166, 166, 167, 168, 168, 168, 168,
394
395 168, 168, 168, 168, 168, 169, 169, 169, 170, 170,
396 170, 170, 170, 170, 170, 170, 171, 172, 172, 172,
397 173, 174, 175, 175, 175, 176, 176, 176, 176, 176,
398 177, 177, 178, 179, 180, 181, 181, 181, 181, 182,
399 182, 182, 183, 184, 185, 186, 187, 187, 188, 189,
400 190, 190, 190, 190, 190, 190, 191, 191, 192, 192,
401 193, 194, 194, 194, 194, 194, 194, 195, 195, 195,
402 195, 195, 195, 195, 195, 195, 196, 196, 196, 196,
403 196, 196, 196, 196, 196, 197, 197, 197, 197, 197,
404 198, 198, 198, 198, 198, 199, 200, 201, 201, 202,
405
406 202, 202, 202, 203, 203, 203, 203, 204, 204, 205,
407 206, 206, 206, 206, 206, 206, 206, 206, 206, 206,
408 206, 206, 206, 207, 207, 207, 207, 207, 207, 207,
409 207, 208, 208, 208, 208, 208, 209, 209, 209, 209,
410 209, 210, 210, 211, 211, 211, 211, 211, 211, 211,
411 211, 211, 211, 211, 211, 211, 212, 212, 213, 214,
412 214, 215, 215, 216, 217, 218, 218, 219, 219
415413 } ;
416414
417415 static yyconst int yy_ec[256] =
455453 3, 3, 3
456454 } ;
457455
458 static yyconst short int yy_base[585] =
456 static yyconst short int yy_base[574] =
459457 { 0,
460 0, 0, 1248, 1249, 1249, 1249, 1243, 1232, 36, 40,
458 0, 0, 1226, 1227, 1227, 1227, 1221, 1210, 36, 40,
461459 44, 50, 56, 62, 0, 63, 66, 81, 89, 47,
462460 108, 91, 95, 92, 72, 109, 134, 119, 117, 160,
463 120, 191, 139, 121, 136, 150, 1241, 1249, 1230, 1249,
461 120, 191, 139, 121, 136, 150, 1219, 1227, 1208, 1227,
464462 0, 165, 180, 197, 219, 70, 224, 239, 244, 0,
465 68, 152, 93, 128, 158, 190, 245, 31, 1229, 188,
466 182, 211, 48, 207, 248, 210, 122, 124, 1228, 209,
463 68, 152, 93, 128, 158, 190, 245, 31, 1207, 188,
464 182, 211, 48, 207, 248, 210, 122, 124, 1206, 209,
467465 257, 258, 185, 259, 260, 261, 262, 263, 264, 265,
468 266, 276, 273, 287, 286, 278, 294, 295, 1227, 297,
466 266, 276, 273, 287, 286, 278, 294, 295, 1205, 297,
469467 299, 300, 305, 306, 303, 313, 307, 311, 301, 316,
470468
471 46, 317, 318, 325, 326, 329, 333, 327, 334, 337,
472 351, 346, 354, 1226, 358, 342, 338, 360, 363, 365,
473 362, 368, 372, 369, 364, 271, 384, 387, 231, 389,
474 394, 1225, 0, 404, 408, 1224, 426, 443, 0, 1223,
475 408, 395, 1222, 409, 412, 1221, 414, 1220, 431, 430,
476 432, 1219, 420, 434, 444, 446, 448, 449, 452, 454,
477 455, 450, 457, 458, 466, 180, 462, 469, 470, 473,
478 474, 472, 475, 477, 484, 486, 480, 490, 487, 497,
479 500, 502, 503, 504, 505, 1218, 506, 1217, 1216, 1215,
480 1214, 1213, 1212, 396, 1211, 1210, 510, 507, 1209, 535,
481
482 512, 511, 516, 514, 546, 525, 1208, 1207, 1206, 526,
483 518, 549, 550, 1205, 1204, 551, 552, 1203, 553, 554,
484 559, 556, 562, 565, 560, 564, 1202, 1201, 1200, 572,
485 566, 1199, 577, 1198, 578, 1197, 1196, 581, 580, 582,
486 585, 517, 588, 586, 592, 597, 1195, 599, 600, 1249,
487 611, 628, 632, 636, 641, 602, 604, 642, 1194, 643,
488 613, 1193, 1192, 605, 644, 645, 646, 647, 649, 648,
489 650, 654, 651, 653, 658, 655, 665, 1191, 1190, 657,
490 670, 673, 676, 1189, 1188, 671, 677, 1187, 678, 681,
491 683, 685, 684, 679, 688, 690, 1186, 1185, 1184, 689,
492
493 696, 1183, 691, 699, 692, 0, 708, 1182, 701, 709,
494 712, 718, 719, 720, 1181, 713, 721, 724, 725, 1180,
495 730, 737, 1179, 734, 723, 1178, 740, 1177, 745, 1176,
496 1175, 746, 748, 750, 752, 749, 1174, 751, 753, 1173,
497 755, 1172, 758, 762, 1171, 785, 1170, 764, 763, 1169,
498 765, 770, 785, 779, 788, 773, 761, 776, 789, 791,
499 792, 796, 797, 1168, 798, 1167, 1166, 799, 801, 802,
500 806, 803, 807, 810, 811, 816, 817, 1165, 820, 821,
501 822, 825, 827, 831, 832, 1164, 824, 838, 1163, 1162,
502 1161, 1160, 1159, 1158, 1157, 839, 841, 843, 1156, 844,
503
504 846, 848, 1155, 1154, 847, 1153, 1152, 852, 850, 849,
505 853, 855, 860, 863, 867, 1151, 870, 871, 1150, 873,
506 874, 875, 876, 877, 878, 879, 1149, 1148, 887, 882,
507 1147, 1146, 1145, 888, 893, 1144, 880, 898, 901, 900,
508 1143, 904, 1142, 1141, 1140, 1139, 908, 902, 910, 1138,
509 912, 914, 1137, 1136, 1135, 1134, 1133, 913, 1132, 1131,
510 1130, 915, 916, 918, 920, 917, 1129, 922, 1128, 928,
511 1127, 1126, 931, 932, 935, 936, 939, 1125, 940, 937,
512 941, 942, 943, 950, 944, 947, 1124, 955, 958, 960,
513 962, 963, 968, 969, 972, 1123, 973, 976, 977, 978,
514
515 1122, 974, 979, 981, 982, 1121, 1118, 1108, 985, 1107,
516 984, 988, 1001, 1106, 1002, 1003, 1005, 1105, 990, 1103,
517 1102, 1006, 1010, 994, 1015, 1012, 1014, 1016, 1021, 1022,
518 1024, 1025, 1026, 1101, 1027, 1030, 1032, 1033, 1036, 1038,
519 1034, 1100, 1039, 1035, 1049, 1052, 1098, 1053, 1042, 1055,
520 1054, 1097, 1058, 1093, 1059, 1063, 1060, 1061, 1066, 1072,
521 1069, 1075, 1077, 1079, 1080, 1081, 1091, 1082, 1083, 726,
522 1088, 616, 1085, 615, 515, 476, 1089, 370, 1249, 1124,
523 1126, 341, 1130, 151
469 46, 317, 318, 325, 326, 329, 333, 327, 334, 330,
470 351, 342, 346, 1204, 358, 354, 337, 361, 360, 363,
471 362, 366, 369, 383, 364, 271, 381, 388, 231, 370,
472 397, 1203, 0, 402, 406, 1202, 429, 446, 0, 1201,
473 406, 412, 1200, 407, 410, 1199, 408, 1198, 413, 419,
474 422, 1197, 433, 414, 447, 448, 435, 449, 452, 451,
475 454, 459, 455, 458, 460, 180, 466, 462, 469, 475,
476 463, 470, 473, 478, 474, 485, 482, 486, 488, 496,
477 497, 498, 499, 501, 503, 1196, 506, 1195, 1194, 1193,
478 1192, 1191, 1190, 504, 1189, 1188, 511, 507, 1187, 535,
479
480 512, 514, 513, 517, 523, 1186, 1185, 1184, 529, 515,
481 547, 548, 1183, 1182, 549, 551, 1181, 552, 553, 558,
482 554, 561, 555, 557, 559, 1180, 1179, 1178, 560, 563,
483 1177, 562, 1176, 567, 1175, 1174, 577, 574, 582, 571,
484 585, 510, 588, 591, 592, 1173, 594, 595, 1227, 604,
485 623, 612, 627, 632, 597, 599, 633, 1172, 634, 635,
486 1171, 1170, 636, 615, 637, 639, 641, 642, 644, 645,
487 647, 648, 649, 652, 656, 659, 1169, 1168, 658, 663,
488 667, 664, 1167, 1166, 668, 669, 1165, 673, 672, 675,
489 676, 678, 680, 679, 684, 1164, 1163, 1162, 685, 687,
490
491 1161, 677, 690, 698, 0, 700, 1160, 704, 705, 1159,
492 706, 708, 710, 711, 1158, 714, 715, 1157, 724, 720,
493 1156, 725, 1155, 727, 1154, 1153, 728, 726, 730, 734,
494 731, 1152, 741, 742, 1151, 743, 1150, 745, 744, 1149,
495 753, 1148, 753, 746, 1147, 747, 761, 759, 765, 770,
496 756, 773, 771, 774, 776, 778, 780, 781, 1146, 782,
497 1145, 1144, 783, 786, 784, 791, 787, 792, 794, 798,
498 803, 804, 1143, 806, 805, 809, 810, 811, 812, 818,
499 1142, 807, 824, 1141, 826, 827, 829, 1140, 411, 828,
500 830, 1139, 1138, 833, 1137, 1136, 835, 832, 834, 838,
501
502 843, 845, 836, 844, 1135, 853, 846, 1134, 854, 855,
503 858, 863, 860, 865, 867, 1133, 1132, 870, 864, 1131,
504 1130, 1129, 873, 868, 1128, 879, 881, 889, 876, 1127,
505 891, 1126, 1125, 1124, 1123, 892, 878, 893, 1122, 896,
506 897, 1121, 1120, 1119, 1118, 1117, 900, 1116, 1115, 1114,
507 901, 902, 903, 904, 906, 1113, 908, 1112, 909, 1111,
508 1110, 914, 915, 918, 919, 920, 1109, 921, 922, 925,
509 926, 928, 933, 932, 937, 1108, 938, 943, 945, 946,
510 947, 951, 948, 953, 1107, 956, 959, 961, 957, 1106,
511 962, 968, 965, 967, 1105, 1104, 1103, 973, 1102, 969,
512
513 972, 975, 1101, 983, 987, 989, 1098, 974, 1088, 1086,
514 991, 994, 993, 995, 998, 999, 1001, 1004, 1005, 1006,
515 1007, 1010, 1085, 1009, 1013, 1012, 1017, 1021, 1024, 1018,
516 1084, 1025, 1032, 1035, 1036, 1083, 1037, 1019, 1026, 1038,
517 1082, 1043, 1077, 1044, 1045, 1049, 1048, 1053, 1054, 1056,
518 1057, 1060, 1063, 1058, 1066, 1076, 1064, 1073, 877, 1068,
519 760, 1071, 707, 604, 522, 1069, 368, 1227, 1104, 1106,
520 349, 1110, 151
524521 } ;
525522
526 static yyconst short int yy_def[585] =
523 static yyconst short int yy_def[574] =
527524 { 0,
528 579, 1, 579, 579, 579, 579, 580, 581, 582, 579,
529 581, 581, 581, 581, 583, 581, 581, 581, 581, 581,
530 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
531 581, 581, 581, 581, 581, 581, 580, 579, 581, 579,
532 584, 584, 579, 579, 581, 581, 581, 581, 581, 583,
533 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
534 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
535 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
536 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
537 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
538
539 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
540 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
541 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
542 581, 579, 584, 584, 579, 581, 581, 581, 49, 581,
543 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
544 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
545 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
546 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
547 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
548 581, 581, 581, 581, 581, 581, 581, 581, 581, 49,
549
550 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
551 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
552 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
553 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
554 581, 581, 581, 581, 581, 581, 581, 581, 581, 579,
555 579, 579, 579, 581, 581, 581, 581, 581, 581, 581,
556 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
557 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
558 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
559 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
560
561 581, 581, 581, 581, 581, 200, 581, 581, 581, 581,
562 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
563 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
564 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
565 581, 581, 581, 581, 581, 579, 581, 581, 581, 581,
566 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
567 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
568 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
569 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
570 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
571
572 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
573 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
574 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
575 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
576 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
577 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
578 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
579 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
580 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
581 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
582
583 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
584 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
585 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
586 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
587 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
588 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
589 581, 581, 581, 581, 581, 581, 581, 581, 581, 581,
590 581, 581, 581, 581, 581, 581, 581, 581, 0, 579,
591 579, 579, 579, 579
525 568, 1, 568, 568, 568, 568, 569, 570, 571, 568,
526 570, 570, 570, 570, 572, 570, 570, 570, 570, 570,
527 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
528 570, 570, 570, 570, 570, 570, 569, 568, 570, 568,
529 573, 573, 568, 568, 570, 570, 570, 570, 570, 572,
530 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
531 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
532 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
533 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
534 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
535
536 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
537 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
538 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
539 570, 568, 573, 573, 568, 570, 570, 570, 49, 570,
540 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
541 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
542 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
543 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
544 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
545 570, 570, 570, 570, 570, 570, 570, 570, 570, 49,
546
547 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
548 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
549 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
550 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
551 570, 570, 570, 570, 570, 570, 570, 570, 568, 568,
552 568, 568, 570, 570, 570, 570, 570, 570, 570, 570,
553 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
554 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
555 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
556 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
557
558 570, 570, 570, 570, 200, 570, 570, 570, 570, 570,
559 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
560 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
561 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
562 568, 570, 570, 570, 570, 570, 570, 570, 570, 570,
563 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
564 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
565 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
566 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
567 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
568
569 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
570 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
571 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
572 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
573 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
574 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
575 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
576 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
577 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
578 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
579
580 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
581 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
582 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
583 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
584 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
585 570, 570, 570, 570, 570, 570, 570, 570, 570, 570,
586 570, 570, 570, 570, 570, 570, 570, 0, 568, 568,
587 568, 568, 568
592588 } ;
593589
594 static yyconst short int yy_nxt[1293] =
590 static yyconst short int yy_nxt[1271] =
595591 { 0,
596592 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
597593 14, 14, 14, 4, 15, 8, 8, 8, 16, 17,
616612 43, 43, 43, 40, 109, 40, 110, 111, 40, 112,
617613
618614 101, 40, 152, 40, 40, 135, 44, 44, 44, 44,
619 117, 166, 118, 119, 147, 120, 151, 121, 279, 122,
615 117, 166, 118, 119, 147, 120, 151, 121, 278, 122,
620616 40, 123, 40, 40, 40, 124, 125, 47, 45, 45,
621617 45, 45, 40, 137, 137, 137, 137, 40, 159, 153,
622 138, 154, 246, 156, 40, 162, 138, 47, 48, 48,
618 138, 154, 245, 156, 40, 162, 138, 47, 48, 48,
623619 48, 48, 40, 139, 139, 139, 139, 40, 40, 139,
624620 139, 40, 139, 139, 139, 139, 139, 139, 157, 148,
625621 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
626 158, 149, 168, 170, 40, 163, 40, 165, 242, 40,
622 158, 149, 168, 170, 40, 163, 40, 165, 241, 40,
627623 167, 40, 164, 173, 172, 178, 169, 174, 171, 40,
628624
629625 40, 175, 176, 179, 177, 181, 184, 40, 40, 180,
630626 40, 183, 40, 40, 40, 185, 40, 182, 40, 40,
631627 40, 194, 189, 186, 40, 187, 40, 191, 193, 40,
632628 40, 40, 188, 196, 195, 198, 190, 197, 40, 40,
633 40, 192, 40, 41, 202, 203, 40, 40, 207, 214,
634 40, 40, 199, 204, 212, 40, 216, 209, 201, 40,
635 210, 205, 208, 215, 40, 206, 211, 40, 217, 213,
636 218, 40, 219, 40, 224, 40, 40, 40, 40, 225,
637 220, 40, 40, 40, 222, 40, 226, 228, 221, 241,
638 232, 240, 230, 235, 236, 223, 227, 40, 231, 233,
639
640 40, 229, 40, 237, 234, 245, 238, 40, 40, 40,
641 243, 239, 244, 134, 134, 134, 134, 251, 251, 251,
642 251, 40, 40, 247, 252, 40, 257, 40, 248, 303,
643 252, 258, 256, 40, 249, 137, 137, 137, 137, 40,
644 260, 264, 138, 40, 40, 40, 259, 40, 138, 253,
645 254, 261, 255, 255, 255, 255, 40, 40, 262, 40,
646 263, 40, 40, 40, 267, 40, 266, 40, 40, 265,
647 40, 40, 274, 272, 270, 40, 268, 269, 271, 40,
648 280, 273, 40, 40, 275, 40, 40, 40, 40, 40,
649 40, 287, 276, 40, 277, 284, 286, 40, 278, 40,
650
651 40, 282, 285, 40, 283, 289, 290, 288, 291, 281,
652 40, 293, 294, 40, 295, 40, 40, 40, 40, 40,
653 40, 297, 292, 40, 40, 40, 298, 40, 40, 40,
654 40, 40, 300, 296, 302, 339, 310, 299, 40, 40,
655 304, 317, 301, 305, 306, 306, 306, 306, 307, 308,
656 306, 306, 309, 306, 306, 306, 306, 306, 306, 40,
657 316, 315, 40, 40, 40, 40, 40, 40, 311, 40,
658 312, 318, 40, 40, 313, 40, 314, 40, 40, 40,
659 320, 319, 323, 324, 326, 40, 321, 328, 325, 322,
660 40, 40, 327, 40, 40, 40, 329, 332, 40, 40,
661
662 334, 40, 330, 335, 341, 40, 336, 333, 331, 340,
663 40, 337, 40, 40, 343, 40, 338, 40, 40, 342,
664 251, 251, 251, 251, 348, 352, 40, 252, 40, 40,
665 344, 351, 347, 252, 253, 253, 345, 346, 346, 346,
666 346, 346, 346, 346, 346, 255, 255, 255, 255, 40,
667 255, 255, 255, 255, 40, 40, 40, 40, 40, 40,
668 40, 40, 40, 40, 40, 356, 40, 40, 40, 361,
669 40, 40, 349, 350, 355, 357, 363, 364, 40, 359,
670 353, 354, 360, 40, 40, 365, 40, 362, 358, 40,
671 40, 40, 40, 366, 40, 372, 40, 40, 40, 371,
672
673 373, 40, 40, 40, 40, 40, 367, 378, 368, 40,
674 369, 377, 40, 370, 40, 374, 376, 375, 380, 379,
675 381, 40, 40, 385, 382, 40, 40, 387, 383, 388,
676 386, 40, 40, 40, 40, 384, 40, 40, 40, 40,
677 390, 392, 394, 40, 396, 389, 397, 40, 398, 395,
678 40, 402, 399, 40, 391, 393, 401, 400, 40, 40,
679 403, 40, 40, 40, 40, 40, 40, 404, 40, 405,
680 408, 40, 406, 407, 40, 40, 40, 40, 40, 409,
681 424, 413, 416, 40, 417, 410, 40, 411, 415, 40,
682 419, 412, 40, 414, 346, 346, 346, 346, 40, 421,
683
684 418, 40, 40, 420, 40, 40, 422, 423, 425, 40,
685 40, 40, 40, 427, 40, 40, 40, 430, 431, 40,
686 40, 426, 428, 40, 40, 432, 429, 433, 435, 40,
687 40, 436, 434, 40, 40, 40, 437, 40, 40, 441,
688 40, 439, 444, 443, 40, 40, 438, 445, 440, 446,
689 442, 40, 40, 447, 40, 449, 40, 40, 448, 40,
690 40, 40, 40, 40, 452, 40, 40, 451, 40, 454,
691 456, 459, 458, 40, 450, 453, 40, 461, 463, 457,
692 40, 462, 455, 40, 40, 460, 40, 40, 40, 40,
693 40, 40, 40, 40, 469, 40, 466, 465, 471, 464,
694
695 40, 40, 480, 468, 475, 476, 40, 467, 478, 473,
696 474, 40, 472, 40, 40, 40, 470, 40, 477, 482,
697 481, 40, 479, 40, 484, 40, 40, 40, 40, 40,
698 40, 40, 486, 40, 488, 40, 483, 489, 490, 493,
699 487, 40, 485, 491, 40, 40, 494, 495, 40, 40,
700 40, 492, 40, 40, 40, 40, 40, 40, 496, 497,
701 40, 502, 503, 40, 501, 498, 499, 504, 40, 505,
702 506, 40, 508, 40, 500, 40, 40, 507, 513, 509,
703 512, 40, 40, 510, 514, 40, 40, 40, 516, 40,
704 40, 40, 40, 511, 40, 40, 518, 40, 40, 515,
705
706 522, 40, 523, 40, 526, 517, 528, 40, 529, 524,
707 519, 527, 520, 521, 40, 40, 40, 525, 40, 40,
708 530, 532, 531, 40, 535, 40, 534, 40, 40, 40,
709 537, 533, 536, 538, 40, 40, 541, 40, 40, 40,
710 40, 539, 544, 40, 546, 40, 40, 40, 40, 40,
711 543, 40, 40, 545, 547, 40, 540, 542, 551, 548,
712 552, 554, 40, 555, 549, 40, 40, 40, 40, 550,
713 553, 40, 40, 40, 40, 558, 40, 556, 559, 40,
714 557, 560, 40, 564, 561, 40, 565, 563, 40, 562,
715 40, 566, 40, 40, 40, 40, 40, 571, 40, 572,
716
717 567, 40, 40, 568, 40, 569, 40, 577, 576, 570,
718 40, 40, 575, 40, 40, 40, 40, 574, 40, 40,
719 40, 40, 573, 578, 37, 37, 37, 37, 39, 39,
629 40, 192, 40, 40, 202, 203, 40, 40, 206, 213,
630 40, 41, 199, 204, 211, 40, 215, 208, 201, 40,
631 209, 216, 207, 214, 40, 205, 210, 40, 218, 212,
632 217, 40, 219, 40, 40, 40, 40, 40, 224, 40,
633 220, 40, 40, 40, 221, 227, 223, 225, 231, 240,
634 234, 235, 229, 226, 40, 222, 40, 232, 230, 228,
635
636 236, 40, 233, 237, 246, 239, 244, 242, 238, 243,
637 40, 134, 134, 134, 134, 250, 250, 250, 250, 40,
638 40, 40, 251, 40, 40, 40, 40, 40, 251, 257,
639 255, 247, 40, 260, 259, 40, 443, 248, 137, 137,
640 137, 137, 40, 256, 258, 138, 40, 261, 40, 264,
641 262, 138, 252, 253, 263, 254, 254, 254, 254, 40,
642 40, 40, 40, 267, 40, 40, 266, 40, 40, 265,
643 271, 40, 40, 40, 269, 40, 40, 268, 270, 40,
644 272, 273, 40, 40, 279, 285, 40, 40, 40, 286,
645 275, 40, 277, 274, 276, 40, 289, 283, 40, 40,
646
647 281, 40, 280, 282, 284, 287, 288, 290, 293, 40,
648 40, 40, 40, 292, 40, 294, 40, 40, 296, 40,
649 40, 291, 297, 40, 40, 40, 40, 40, 40, 299,
650 40, 335, 295, 298, 301, 40, 40, 302, 312, 309,
651 300, 303, 40, 304, 305, 305, 305, 305, 306, 308,
652 305, 305, 307, 305, 305, 305, 305, 305, 305, 310,
653 40, 40, 40, 311, 40, 40, 40, 40, 40, 313,
654 40, 40, 40, 40, 40, 40, 40, 323, 315, 314,
655 40, 318, 319, 321, 40, 316, 320, 40, 317, 329,
656 40, 322, 328, 324, 327, 40, 326, 325, 40, 330,
657
658 331, 40, 333, 334, 40, 40, 336, 40, 40, 338,
659 40, 332, 40, 250, 250, 250, 250, 40, 337, 343,
660 251, 341, 341, 341, 341, 339, 251, 342, 40, 252,
661 252, 340, 341, 341, 341, 341, 254, 254, 254, 254,
662 40, 254, 254, 254, 254, 40, 40, 40, 40, 40,
663 40, 348, 40, 346, 40, 40, 347, 40, 40, 351,
664 40, 40, 40, 344, 345, 40, 356, 350, 352, 40,
665 358, 40, 40, 349, 354, 355, 40, 40, 359, 360,
666 40, 40, 40, 357, 353, 40, 40, 367, 40, 40,
667 40, 40, 40, 40, 361, 368, 366, 40, 40, 362,
668
669 40, 365, 363, 40, 364, 372, 369, 371, 373, 370,
670 374, 40, 375, 40, 378, 377, 376, 40, 40, 40,
671 40, 40, 381, 40, 40, 383, 379, 40, 40, 380,
672 382, 385, 386, 40, 387, 389, 388, 40, 40, 40,
673 40, 40, 384, 40, 40, 392, 390, 40, 391, 393,
674 395, 394, 397, 396, 40, 40, 40, 40, 40, 40,
675 40, 398, 341, 341, 341, 341, 40, 406, 402, 40,
676 404, 405, 40, 40, 40, 399, 400, 409, 40, 401,
677 403, 408, 407, 40, 40, 410, 40, 40, 411, 40,
678 412, 40, 413, 40, 40, 40, 40, 40, 416, 40,
679
680 40, 419, 420, 414, 40, 40, 415, 40, 417, 421,
681 418, 40, 422, 424, 423, 425, 40, 40, 40, 40,
682 40, 426, 40, 40, 40, 40, 430, 432, 428, 433,
683 427, 40, 434, 435, 436, 429, 431, 40, 438, 40,
684 40, 40, 40, 40, 437, 40, 40, 40, 40, 40,
685 441, 40, 445, 448, 440, 447, 40, 40, 40, 40,
686 439, 442, 450, 452, 444, 446, 40, 40, 40, 451,
687 449, 40, 453, 40, 454, 458, 40, 40, 40, 455,
688 40, 40, 456, 40, 457, 460, 40, 464, 465, 40,
689 40, 40, 40, 467, 40, 461, 462, 468, 463, 459,
690
691 466, 469, 40, 470, 40, 40, 40, 471, 475, 40,
692 40, 473, 472, 40, 40, 40, 40, 40, 477, 40,
693 478, 40, 40, 476, 482, 479, 474, 40, 40, 480,
694 483, 40, 40, 40, 40, 40, 484, 481, 40, 40,
695 486, 40, 491, 492, 485, 40, 40, 490, 487, 488,
696 40, 40, 493, 494, 495, 497, 40, 489, 40, 40,
697 40, 40, 496, 502, 40, 501, 40, 498, 503, 40,
698 40, 505, 40, 499, 40, 40, 500, 507, 40, 511,
699 40, 40, 40, 504, 506, 40, 40, 40, 40, 515,
700 512, 517, 518, 508, 519, 509, 40, 510, 513, 516,
701
702 40, 514, 40, 520, 40, 521, 40, 40, 40, 524,
703 523, 40, 40, 527, 40, 522, 525, 40, 40, 40,
704 40, 530, 40, 40, 533, 40, 40, 528, 535, 526,
705 40, 40, 40, 532, 40, 534, 536, 40, 40, 40,
706 531, 529, 537, 540, 538, 40, 541, 543, 40, 40,
707 40, 40, 549, 539, 542, 548, 40, 40, 40, 547,
708 544, 40, 40, 545, 546, 553, 40, 40, 550, 40,
709 40, 40, 552, 40, 551, 554, 40, 40, 555, 40,
710 560, 40, 40, 561, 40, 557, 40, 556, 565, 40,
711 40, 559, 558, 566, 564, 40, 40, 40, 40, 40,
712
713 562, 40, 563, 567, 37, 37, 37, 37, 39, 39,
720714 50, 40, 50, 50, 40, 40, 40, 40, 40, 40,
721715 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
722716 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
724718 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
725719 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
726720 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
727
728721 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
729722 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
723
730724 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
731 40, 40, 40, 40, 40, 40, 40, 40, 250, 40,
732 40, 40, 40, 40, 132, 40, 38, 579, 3, 579,
733 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
734 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
735 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
736 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
737 579, 579
738
725 40, 40, 40, 40, 40, 40, 249, 40, 40, 40,
726 40, 40, 132, 40, 38, 568, 3, 568, 568, 568,
727 568, 568, 568, 568, 568, 568, 568, 568, 568, 568,
728 568, 568, 568, 568, 568, 568, 568, 568, 568, 568,
729 568, 568, 568, 568, 568, 568, 568, 568, 568, 568,
730 568, 568, 568, 568, 568, 568, 568, 568, 568, 568
739731 } ;
740732
741 static yyconst short int yy_chk[1293] =
733 static yyconst short int yy_chk[1271] =
742734 { 0,
743735 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
744736 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
756748 19, 21, 26, 24, 23, 23, 21, 24, 21, 21,
757749 29, 26, 28, 31, 34, 67, 21, 68, 31, 29,
758750 21, 54, 21, 34, 28, 68, 26, 27, 35, 35,
759 28, 31, 33, 584, 31, 28, 27, 33, 27, 67,
751 28, 31, 33, 573, 31, 28, 27, 33, 27, 67,
760752 54, 31, 27, 36, 27, 52, 27, 35, 27, 30,
761753 33, 55, 36, 30, 42, 42, 42, 42, 52, 30,
762754 52, 30, 30, 55, 30, 30, 30, 55, 30, 43,
777769 90, 85, 91, 92, 99, 87, 95, 84, 93, 94,
778770 97, 95, 92, 88, 98, 90, 96, 93, 94, 100,
779771 102, 103, 91, 97, 96, 99, 92, 98, 104, 105,
780 108, 93, 106, 582, 103, 104, 107, 109, 105, 108,
781 110, 117, 100, 104, 107, 116, 109, 106, 102, 112,
782 106, 104, 105, 108, 111, 104, 106, 113, 110, 107,
783 111, 115, 112, 118, 116, 121, 119, 125, 120, 117,
784 113, 122, 124, 578, 115, 123, 118, 120, 113, 125,
785 122, 124, 121, 123, 123, 115, 119, 127, 121, 122,
786
787 128, 120, 130, 123, 122, 128, 123, 131, 142, 194,
788 127, 123, 127, 134, 134, 134, 134, 135, 135, 135,
789 135, 141, 144, 130, 135, 145, 142, 147, 131, 194,
790 135, 144, 141, 153, 131, 137, 137, 137, 137, 137,
791 147, 153, 137, 150, 149, 151, 145, 154, 137, 138,
792 138, 149, 138, 138, 138, 138, 138, 155, 150, 156,
793 151, 157, 158, 162, 156, 159, 155, 160, 161, 154,
794 163, 164, 162, 160, 159, 167, 157, 158, 159, 165,
795 167, 161, 168, 169, 162, 172, 170, 171, 173, 576,
796 174, 172, 163, 177, 164, 170, 171, 175, 165, 176,
797
798 179, 169, 170, 178, 169, 174, 175, 173, 176, 168,
799 180, 177, 178, 181, 179, 182, 183, 184, 185, 187,
800 198, 181, 176, 197, 202, 201, 182, 204, 575, 203,
801 242, 211, 184, 180, 187, 242, 204, 183, 206, 210,
802 197, 211, 185, 198, 200, 200, 200, 200, 201, 202,
803 200, 200, 203, 200, 200, 200, 200, 200, 200, 205,
804 210, 206, 212, 213, 216, 217, 219, 220, 205, 222,
805 205, 212, 221, 225, 205, 223, 205, 226, 224, 231,
806 216, 213, 220, 221, 223, 230, 217, 224, 222, 219,
807 233, 235, 223, 239, 238, 240, 225, 231, 241, 244,
808
809 235, 243, 226, 238, 244, 245, 239, 233, 230, 243,
810 246, 240, 248, 249, 246, 256, 241, 257, 264, 245,
811 251, 251, 251, 251, 257, 264, 261, 251, 574, 572,
812 248, 261, 256, 251, 252, 252, 249, 252, 252, 252,
813 252, 253, 253, 253, 253, 254, 254, 254, 254, 254,
814 255, 255, 255, 255, 255, 258, 260, 265, 266, 267,
815 268, 270, 269, 271, 273, 268, 274, 272, 276, 273,
816 280, 275, 258, 260, 267, 269, 275, 276, 277, 271,
817 265, 266, 272, 281, 286, 277, 282, 274, 270, 283,
818 287, 289, 294, 280, 290, 287, 291, 293, 292, 286,
819
820 289, 295, 300, 296, 303, 305, 281, 294, 282, 301,
821 282, 293, 304, 283, 309, 290, 292, 291, 296, 295,
822 300, 307, 310, 305, 301, 311, 316, 309, 303, 310,
823 307, 312, 313, 314, 317, 304, 325, 318, 319, 570,
824 312, 313, 314, 321, 317, 311, 318, 324, 319, 316,
825 322, 325, 321, 327, 312, 313, 324, 322, 329, 332,
826 327, 333, 336, 334, 338, 335, 339, 329, 341, 332,
827 335, 343, 333, 334, 357, 344, 349, 348, 351, 336,
828 357, 343, 348, 352, 349, 338, 356, 339, 344, 358,
829 352, 341, 354, 343, 346, 346, 346, 346, 353, 354,
830
831 351, 355, 359, 353, 360, 361, 355, 356, 358, 362,
832 363, 365, 368, 360, 369, 370, 372, 363, 365, 371,
833 373, 359, 361, 374, 375, 368, 362, 369, 371, 376,
834 377, 372, 370, 379, 380, 381, 373, 387, 382, 377,
835 383, 375, 381, 380, 384, 385, 374, 382, 376, 383,
836 379, 388, 396, 384, 397, 387, 398, 400, 385, 401,
837 405, 402, 410, 409, 397, 408, 411, 396, 412, 400,
838 402, 409, 408, 413, 388, 398, 414, 411, 413, 405,
839 415, 412, 401, 417, 418, 410, 420, 421, 422, 423,
840 424, 425, 426, 437, 421, 430, 417, 415, 423, 414,
841
842 429, 434, 437, 420, 429, 429, 435, 418, 434, 425,
843 426, 438, 424, 440, 439, 448, 422, 442, 430, 439,
844 438, 447, 435, 449, 442, 451, 458, 452, 462, 463,
845 466, 464, 448, 465, 451, 468, 440, 452, 458, 464,
846 449, 470, 447, 462, 473, 474, 465, 466, 475, 476,
847 480, 463, 477, 479, 481, 482, 483, 485, 468, 470,
848 486, 477, 479, 484, 476, 473, 474, 480, 488, 481,
849 482, 489, 484, 490, 475, 491, 492, 483, 490, 485,
850 489, 493, 494, 486, 491, 495, 497, 502, 493, 498,
851 499, 500, 503, 488, 504, 505, 495, 511, 509, 492,
852
853 500, 512, 502, 519, 505, 494, 511, 524, 512, 503,
854 497, 509, 498, 499, 513, 515, 516, 504, 517, 522,
855 513, 516, 515, 523, 522, 526, 519, 527, 525, 528,
856 524, 517, 523, 525, 529, 530, 528, 531, 532, 533,
857 535, 526, 531, 536, 533, 537, 538, 541, 544, 539,
858 530, 540, 543, 532, 535, 549, 527, 529, 539, 536,
859 540, 543, 545, 544, 537, 546, 548, 551, 550, 538,
860 541, 553, 555, 557, 558, 548, 556, 545, 549, 559,
861 546, 550, 561, 556, 551, 560, 557, 555, 562, 553,
862 563, 558, 564, 565, 566, 568, 569, 563, 573, 564,
863
864 559, 571, 577, 560, 567, 561, 554, 573, 571, 562,
865 552, 547, 568, 542, 534, 521, 520, 566, 518, 514,
866 510, 508, 565, 577, 580, 580, 580, 580, 581, 581,
867 583, 507, 583, 583, 506, 501, 496, 487, 478, 472,
868 471, 469, 467, 461, 460, 459, 457, 456, 455, 454,
869 453, 450, 446, 445, 444, 443, 441, 436, 433, 432,
870 431, 428, 427, 419, 416, 407, 406, 404, 403, 399,
871 395, 394, 393, 392, 391, 390, 389, 386, 378, 367,
872 366, 364, 350, 347, 345, 342, 340, 337, 331, 330,
873 328, 326, 323, 320, 315, 308, 302, 299, 298, 297,
874
875 288, 285, 284, 279, 278, 263, 262, 259, 247, 237,
876 236, 234, 232, 229, 228, 227, 218, 215, 214, 209,
877 208, 207, 199, 196, 195, 193, 192, 191, 190, 189,
878 188, 186, 152, 148, 146, 143, 140, 136, 132, 114,
879 89, 69, 59, 39, 37, 8, 7, 3, 579, 579,
880 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
881 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
882 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
883 579, 579, 579, 579, 579, 579, 579, 579, 579, 579,
884 579, 579
885
772 108, 93, 106, 110, 103, 104, 107, 109, 105, 108,
773 117, 571, 100, 104, 107, 112, 109, 106, 102, 113,
774 106, 110, 105, 108, 111, 104, 106, 116, 112, 107,
775 111, 115, 113, 119, 118, 121, 120, 125, 117, 122,
776 113, 567, 123, 130, 115, 120, 116, 118, 122, 125,
777 123, 123, 121, 119, 127, 115, 124, 122, 121, 120,
778
779 123, 128, 122, 123, 130, 124, 128, 127, 123, 127,
780 131, 134, 134, 134, 134, 135, 135, 135, 135, 141,
781 144, 147, 135, 145, 389, 142, 149, 154, 135, 144,
782 141, 131, 150, 149, 147, 151, 389, 131, 137, 137,
783 137, 137, 137, 142, 145, 137, 153, 150, 157, 154,
784 151, 137, 138, 138, 153, 138, 138, 138, 138, 138,
785 155, 156, 158, 157, 160, 159, 156, 161, 163, 155,
786 160, 164, 162, 165, 159, 168, 171, 158, 159, 167,
787 161, 162, 169, 172, 167, 171, 173, 175, 170, 172,
788 163, 174, 165, 162, 164, 177, 175, 170, 176, 178,
789
790 169, 179, 168, 169, 170, 173, 174, 176, 178, 180,
791 181, 182, 183, 177, 184, 179, 185, 194, 181, 187,
792 198, 176, 182, 242, 197, 201, 203, 202, 210, 184,
793 204, 242, 180, 183, 187, 565, 205, 194, 210, 204,
794 185, 197, 209, 198, 200, 200, 200, 200, 201, 203,
795 200, 200, 202, 200, 200, 200, 200, 200, 200, 205,
796 211, 212, 215, 209, 216, 218, 219, 221, 223, 211,
797 224, 220, 225, 229, 222, 232, 230, 223, 215, 212,
798 234, 219, 220, 222, 240, 216, 221, 238, 218, 234,
799 237, 222, 232, 224, 230, 239, 229, 225, 241, 237,
800
801 238, 243, 240, 241, 244, 245, 243, 247, 248, 245,
802 255, 239, 256, 250, 250, 250, 250, 564, 244, 256,
803 250, 252, 252, 252, 252, 247, 250, 255, 264, 251,
804 251, 248, 251, 251, 251, 251, 253, 253, 253, 253,
805 253, 254, 254, 254, 254, 254, 257, 259, 260, 263,
806 265, 264, 266, 260, 267, 268, 263, 269, 270, 267,
807 271, 272, 273, 257, 259, 274, 272, 266, 268, 275,
808 274, 279, 276, 265, 270, 271, 280, 282, 275, 276,
809 281, 285, 286, 273, 269, 289, 288, 286, 290, 291,
810 302, 292, 294, 293, 279, 288, 285, 295, 299, 280,
811
812 300, 282, 281, 303, 281, 292, 289, 291, 293, 290,
813 294, 304, 295, 306, 302, 300, 299, 308, 309, 311,
814 563, 312, 306, 313, 314, 309, 303, 316, 317, 304,
815 308, 312, 313, 320, 314, 317, 316, 319, 322, 328,
816 324, 327, 311, 329, 331, 322, 319, 330, 320, 324,
817 328, 327, 330, 329, 333, 334, 336, 339, 338, 344,
818 346, 331, 341, 341, 341, 341, 343, 344, 338, 351,
819 339, 343, 348, 561, 347, 333, 334, 348, 349, 336,
820 338, 347, 346, 350, 353, 349, 352, 354, 350, 355,
821 351, 356, 352, 357, 358, 360, 363, 365, 355, 364,
822
823 367, 358, 360, 353, 366, 368, 354, 369, 356, 363,
824 357, 370, 364, 366, 365, 367, 371, 372, 375, 374,
825 382, 368, 376, 377, 378, 379, 372, 375, 370, 376,
826 369, 380, 377, 378, 379, 371, 374, 383, 382, 385,
827 386, 390, 387, 391, 380, 398, 394, 399, 397, 403,
828 386, 400, 391, 398, 385, 397, 401, 404, 402, 407,
829 383, 387, 400, 402, 390, 394, 406, 409, 410, 401,
830 399, 411, 403, 413, 404, 410, 412, 419, 414, 406,
831 415, 424, 407, 418, 409, 412, 423, 418, 418, 429,
832 559, 437, 426, 423, 427, 413, 414, 424, 415, 411,
833
834 419, 426, 428, 427, 431, 436, 438, 428, 437, 440,
835 441, 431, 429, 447, 451, 452, 453, 454, 440, 455,
836 441, 457, 459, 438, 453, 447, 436, 462, 463, 451,
837 454, 464, 465, 466, 468, 469, 455, 452, 470, 471,
838 459, 472, 466, 468, 457, 474, 473, 465, 462, 463,
839 475, 477, 469, 470, 471, 473, 478, 464, 479, 480,
840 481, 483, 472, 479, 482, 478, 484, 474, 480, 486,
841 489, 482, 487, 475, 488, 491, 477, 484, 493, 489,
842 494, 492, 500, 481, 483, 501, 498, 508, 502, 494,
843 491, 500, 501, 486, 502, 487, 504, 488, 492, 498,
844
845 505, 493, 506, 504, 511, 505, 513, 512, 514, 511,
846 508, 515, 516, 514, 517, 506, 512, 518, 519, 520,
847 521, 517, 524, 522, 520, 526, 525, 515, 522, 513,
848 527, 530, 538, 519, 528, 521, 524, 529, 532, 539,
849 518, 516, 525, 528, 526, 533, 529, 532, 534, 535,
850 537, 540, 539, 527, 530, 538, 542, 544, 545, 537,
851 533, 547, 546, 534, 535, 545, 548, 549, 540, 550,
852 551, 554, 544, 552, 542, 546, 553, 557, 547, 555,
853 552, 560, 566, 553, 562, 549, 558, 548, 560, 556,
854 543, 551, 550, 562, 557, 541, 536, 531, 523, 510,
855
856 554, 509, 555, 566, 569, 569, 569, 569, 570, 570,
857 572, 507, 572, 572, 503, 499, 497, 496, 495, 490,
858 485, 476, 467, 461, 460, 458, 456, 450, 449, 448,
859 446, 445, 444, 443, 442, 439, 435, 434, 433, 432,
860 430, 425, 422, 421, 420, 417, 416, 408, 405, 396,
861 395, 393, 392, 388, 384, 381, 373, 362, 361, 359,
862 345, 342, 340, 337, 335, 332, 326, 325, 323, 321,
863 318, 315, 310, 307, 301, 298, 297, 296, 287, 284,
864 283, 278, 277, 262, 261, 258, 246, 236, 235, 233,
865 231, 228, 227, 226, 217, 214, 213, 208, 207, 206,
866
867 199, 196, 195, 193, 192, 191, 190, 189, 188, 186,
868 152, 148, 146, 143, 140, 136, 132, 114, 89, 69,
869 59, 39, 37, 8, 7, 3, 568, 568, 568, 568,
870 568, 568, 568, 568, 568, 568, 568, 568, 568, 568,
871 568, 568, 568, 568, 568, 568, 568, 568, 568, 568,
872 568, 568, 568, 568, 568, 568, 568, 568, 568, 568,
873 568, 568, 568, 568, 568, 568, 568, 568, 568, 568
886874 } ;
887875
888876 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
899887 #define YY_MORE_ADJ 0
900888 #define YY_RESTORE_YY_MORE_OFFSET
901889 char *yytext;
902 #line 1 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
890 #line 1 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
903891 #define INITIAL 0
904892 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
905893 //
914902 //
915903 //===----------------------------------------------------------------------===*/
916904 #define YY_NEVER_INTERACTIVE 1
917 #line 28 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
905 #line 28 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
918906 #include "ParserInternals.h"
919907 #include "llvm/Module.h"
920908 #include
10471035 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
10481036 * it to deal with 64 bit numbers.
10491037 */
1050 #line 1052 "Lexer.cpp"
1038 #line 1040 "Lexer.cpp"
10511039
10521040 /* Macros after this point can all be overridden by user definitions in
10531041 * section 1.
11981186 register char *yy_cp = NULL, *yy_bp = NULL;
11991187 register int yy_act;
12001188
1201 #line 186 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1202
1203
1204 #line 1206 "Lexer.cpp"
1189 #line 186 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1190
1191
1192 #line 1194 "Lexer.cpp"
12051193
12061194 if ( yy_init )
12071195 {
12491237 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
12501238 {
12511239 yy_current_state = (int) yy_def[yy_current_state];
1252 if ( yy_current_state >= 580 )
1240 if ( yy_current_state >= 569 )
12531241 yy_c = yy_meta[(unsigned int) yy_c];
12541242 }
12551243 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
12561244 *yy_state_ptr++ = yy_current_state;
12571245 ++yy_cp;
12581246 }
1259 while ( yy_current_state != 579 );
1247 while ( yy_current_state != 568 );
12601248
12611249 yy_find_action:
12621250 yy_current_state = *--yy_state_ptr;
12941282 { /* beginning of action switch */
12951283 case 1:
12961284 YY_RULE_SETUP
1297 #line 188 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1285 #line 188 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
12981286 { /* Ignore comments for now */ }
12991287 YY_BREAK
13001288 case 2:
13011289 YY_RULE_SETUP
1302 #line 190 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1290 #line 190 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13031291 { return BEGINTOK; }
13041292 YY_BREAK
13051293 case 3:
13061294 YY_RULE_SETUP
1307 #line 191 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1295 #line 191 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13081296 { return ENDTOK; }
13091297 YY_BREAK
13101298 case 4:
13111299 YY_RULE_SETUP
1312 #line 192 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1300 #line 192 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13131301 { return TRUETOK; }
13141302 YY_BREAK
13151303 case 5:
13161304 YY_RULE_SETUP
1317 #line 193 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1305 #line 193 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13181306 { return FALSETOK; }
13191307 YY_BREAK
13201308 case 6:
13211309 YY_RULE_SETUP
1322 #line 194 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1310 #line 194 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13231311 { return DECLARE; }
13241312 YY_BREAK
13251313 case 7:
13261314 YY_RULE_SETUP
1327 #line 195 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1315 #line 195 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13281316 { return GLOBAL; }
13291317 YY_BREAK
13301318 case 8:
13311319 YY_RULE_SETUP
1332 #line 196 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1320 #line 196 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13331321 { return CONSTANT; }
13341322 YY_BREAK
13351323 case 9:
13361324 YY_RULE_SETUP
1337 #line 197 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1325 #line 197 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13381326 { return INTERNAL; }
13391327 YY_BREAK
13401328 case 10:
13411329 YY_RULE_SETUP
1342 #line 198 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1330 #line 198 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13431331 { return LINKONCE; }
13441332 YY_BREAK
13451333 case 11:
13461334 YY_RULE_SETUP
1347 #line 199 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1335 #line 199 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13481336 { return WEAK; }
13491337 YY_BREAK
13501338 case 12:
13511339 YY_RULE_SETUP
1352 #line 200 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1340 #line 200 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13531341 { return APPENDING; }
13541342 YY_BREAK
13551343 case 13:
13561344 YY_RULE_SETUP
1357 #line 201 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1345 #line 201 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13581346 { return DLLIMPORT; }
13591347 YY_BREAK
13601348 case 14:
13611349 YY_RULE_SETUP
1362 #line 202 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1350 #line 202 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13631351 { return DLLEXPORT; }
13641352 YY_BREAK
13651353 case 15:
13661354 YY_RULE_SETUP
1367 #line 203 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1355 #line 203 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13681356 { return EXTERN_WEAK; }
13691357 YY_BREAK
13701358 case 16:
13711359 YY_RULE_SETUP
1372 #line 204 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1360 #line 204 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13731361 { return EXTERNAL; }
13741362 YY_BREAK
13751363 case 17:
13761364 YY_RULE_SETUP
1377 #line 205 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1365 #line 205 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13781366 { return IMPLEMENTATION; }
13791367 YY_BREAK
13801368 case 18:
13811369 YY_RULE_SETUP
1382 #line 206 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1370 #line 206 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13831371 { return ZEROINITIALIZER; }
13841372 YY_BREAK
13851373 case 19:
13861374 YY_RULE_SETUP
1387 #line 207 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1375 #line 207 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13881376 { return DOTDOTDOT; }
13891377 YY_BREAK
13901378 case 20:
13911379 YY_RULE_SETUP
1392 #line 208 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1380 #line 208 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13931381 { return UNDEF; }
13941382 YY_BREAK
13951383 case 21:
13961384 YY_RULE_SETUP
1397 #line 209 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1385 #line 209 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
13981386 { return NULL_TOK; }
13991387 YY_BREAK
14001388 case 22:
14011389 YY_RULE_SETUP
1402 #line 210 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1390 #line 210 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14031391 { return TO; }
14041392 YY_BREAK
14051393 case 23:
14061394 YY_RULE_SETUP
1407 #line 211 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1395 #line 211 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14081396 { return TAIL; }
14091397 YY_BREAK
14101398 case 24:
14111399 YY_RULE_SETUP
1412 #line 212 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1400 #line 212 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14131401 { return TARGET; }
14141402 YY_BREAK
14151403 case 25:
14161404 YY_RULE_SETUP
1417 #line 213 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1405 #line 213 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14181406 { return TRIPLE; }
14191407 YY_BREAK
14201408 case 26:
14211409 YY_RULE_SETUP
1422 #line 214 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1410 #line 214 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14231411 { return DEPLIBS; }
14241412 YY_BREAK
14251413 case 27:
14261414 YY_RULE_SETUP
1427 #line 215 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1415 #line 215 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14281416 { return ENDIAN; }
14291417 YY_BREAK
14301418 case 28:
14311419 YY_RULE_SETUP
1432 #line 216 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1420 #line 216 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14331421 { return POINTERSIZE; }
14341422 YY_BREAK
14351423 case 29:
14361424 YY_RULE_SETUP
1437 #line 217 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1425 #line 217 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14381426 { return DATALAYOUT; }
14391427 YY_BREAK
14401428 case 30:
14411429 YY_RULE_SETUP
1442 #line 218 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1430 #line 218 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14431431 { return LITTLE; }
14441432 YY_BREAK
14451433 case 31:
14461434 YY_RULE_SETUP
1447 #line 219 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1435 #line 219 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14481436 { return BIG; }
14491437 YY_BREAK
14501438 case 32:
14511439 YY_RULE_SETUP
1452 #line 220 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1440 #line 220 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14531441 { return VOLATILE; }
14541442 YY_BREAK
14551443 case 33:
14561444 YY_RULE_SETUP
1457 #line 221 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1445 #line 221 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14581446 { return ALIGN; }
14591447 YY_BREAK
14601448 case 34:
14611449 YY_RULE_SETUP
1462 #line 222 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1450 #line 222 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14631451 { return SECTION; }
14641452 YY_BREAK
14651453 case 35:
14661454 YY_RULE_SETUP
1467 #line 223 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1455 #line 223 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14681456 { return MODULE; }
14691457 YY_BREAK
14701458 case 36:
14711459 YY_RULE_SETUP
1472 #line 224 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1460 #line 224 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14731461 { return ASM_TOK; }
14741462 YY_BREAK
14751463 case 37:
14761464 YY_RULE_SETUP
1477 #line 225 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1465 #line 225 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14781466 { return SIDEEFFECT; }
14791467 YY_BREAK
14801468 case 38:
14811469 YY_RULE_SETUP
1482 #line 227 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1470 #line 227 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14831471 { return CC_TOK; }
14841472 YY_BREAK
14851473 case 39:
14861474 YY_RULE_SETUP
1487 #line 228 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1475 #line 228 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14881476 { return CCC_TOK; }
14891477 YY_BREAK
14901478 case 40:
14911479 YY_RULE_SETUP
1492 #line 229 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1480 #line 229 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14931481 { return CSRETCC_TOK; }
14941482 YY_BREAK
14951483 case 41:
14961484 YY_RULE_SETUP
1497 #line 230 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1485 #line 230 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
14981486 { return FASTCC_TOK; }
14991487 YY_BREAK
15001488 case 42:
15011489 YY_RULE_SETUP
1502 #line 231 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1490 #line 231 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15031491 { return COLDCC_TOK; }
15041492 YY_BREAK
15051493 case 43:
15061494 YY_RULE_SETUP
1507 #line 232 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1495 #line 232 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15081496 { return X86_STDCALLCC_TOK; }
15091497 YY_BREAK
15101498 case 44:
15111499 YY_RULE_SETUP
1512 #line 233 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1500 #line 233 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15131501 { return X86_FASTCALLCC_TOK; }
15141502 YY_BREAK
15151503 case 45:
15161504 YY_RULE_SETUP
1517 #line 235 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1505 #line 235 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15181506 { RET_TY(Type::VoidTy, VOID); }
15191507 YY_BREAK
15201508 case 46:
15211509 YY_RULE_SETUP
1522 #line 236 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1510 #line 236 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15231511 { RET_TY(Type::BoolTy, BOOL); }
15241512 YY_BREAK
15251513 case 47:
15261514 YY_RULE_SETUP
1527 #line 237 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1515 #line 237 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15281516 { RET_TY(Type::SByteTy, SBYTE); }
15291517 YY_BREAK
15301518 case 48:
15311519 YY_RULE_SETUP
1532 #line 238 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1520 #line 238 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15331521 { RET_TY(Type::UByteTy, UBYTE); }
15341522 YY_BREAK
15351523 case 49:
15361524 YY_RULE_SETUP
1537 #line 239 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1525 #line 239 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15381526 { RET_TY(Type::ShortTy, SHORT); }
15391527 YY_BREAK
15401528 case 50:
15411529 YY_RULE_SETUP
1542 #line 240 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1530 #line 240 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15431531 { RET_TY(Type::UShortTy,USHORT);}
15441532 YY_BREAK
15451533 case 51:
15461534 YY_RULE_SETUP
1547 #line 241 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1535 #line 241 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15481536 { RET_TY(Type::IntTy, INT); }
15491537 YY_BREAK
15501538 case 52:
15511539 YY_RULE_SETUP
1552 #line 242 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1540 #line 242 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15531541 { RET_TY(Type::UIntTy, UINT); }
15541542 YY_BREAK
15551543 case 53:
15561544 YY_RULE_SETUP
1557 #line 243 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1545 #line 243 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15581546 { RET_TY(Type::LongTy, LONG); }
15591547 YY_BREAK
15601548 case 54:
15611549 YY_RULE_SETUP
1562 #line 244 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1550 #line 244 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15631551 { RET_TY(Type::ULongTy, ULONG); }
15641552 YY_BREAK
15651553 case 55:
15661554 YY_RULE_SETUP
1567 #line 245 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1555 #line 245 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15681556 { RET_TY(Type::FloatTy, FLOAT); }
15691557 YY_BREAK
15701558 case 56:
15711559 YY_RULE_SETUP
1572 #line 246 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1560 #line 246 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15731561 { RET_TY(Type::DoubleTy,DOUBLE);}
15741562 YY_BREAK
15751563 case 57:
15761564 YY_RULE_SETUP
1577 #line 247 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1565 #line 247 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15781566 { RET_TY(Type::LabelTy, LABEL); }
15791567 YY_BREAK
15801568 case 58:
15811569 YY_RULE_SETUP
1582 #line 248 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1570 #line 248 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15831571 { return TYPE; }
15841572 YY_BREAK
15851573 case 59:
15861574 YY_RULE_SETUP
1587 #line 249 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1575 #line 249 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15881576 { return OPAQUE; }
15891577 YY_BREAK
15901578 case 60:
15911579 YY_RULE_SETUP
1592 #line 251 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1580 #line 251 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15931581 { RET_TOK(BinaryOpVal, Add, ADD); }
15941582 YY_BREAK
15951583 case 61:
15961584 YY_RULE_SETUP
1597 #line 252 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1585 #line 252 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
15981586 { RET_TOK(BinaryOpVal, Sub, SUB); }
15991587 YY_BREAK
16001588 case 62:
16011589 YY_RULE_SETUP
1602 #line 253 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1590 #line 253 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16031591 { RET_TOK(BinaryOpVal, Mul, MUL); }
16041592 YY_BREAK
16051593 case 63:
16061594 YY_RULE_SETUP
1607 #line 254 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1595 #line 254 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16081596 { RET_TOK(BinaryOpVal, UDiv, UDIV); }
16091597 YY_BREAK
16101598 case 64:
16111599 YY_RULE_SETUP
1612 #line 255 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1600 #line 255 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16131601 { RET_TOK(BinaryOpVal, SDiv, SDIV); }
16141602 YY_BREAK
16151603 case 65:
16161604 YY_RULE_SETUP
1617 #line 256 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1605 #line 256 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16181606 { RET_TOK(BinaryOpVal, FDiv, FDIV); }
16191607 YY_BREAK
16201608 case 66:
16211609 YY_RULE_SETUP
1622 #line 257 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1610 #line 257 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16231611 { RET_TOK(BinaryOpVal, URem, UREM); }
16241612 YY_BREAK
16251613 case 67:
16261614 YY_RULE_SETUP
1627 #line 258 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1615 #line 258 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16281616 { RET_TOK(BinaryOpVal, SRem, SREM); }
16291617 YY_BREAK
16301618 case 68:
16311619 YY_RULE_SETUP
1632 #line 259 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1620 #line 259 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16331621 { RET_TOK(BinaryOpVal, FRem, FREM); }
16341622 YY_BREAK
16351623 case 69:
16361624 YY_RULE_SETUP
1637 #line 260 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1625 #line 260 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16381626 { RET_TOK(BinaryOpVal, And, AND); }
16391627 YY_BREAK
16401628 case 70:
16411629 YY_RULE_SETUP
1642 #line 261 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1630 #line 261 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16431631 { RET_TOK(BinaryOpVal, Or , OR ); }
16441632 YY_BREAK
16451633 case 71:
16461634 YY_RULE_SETUP
1647 #line 262 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1635 #line 262 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
16481636 { RET_TOK(BinaryOpVal, Xor, XOR); }
16491637 YY_BREAK
16501638 case 72:
16511639 YY_RULE_SETUP
1652 #line 263 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1653 { RET_TOK(BinaryOpVal, SetNE, SETNE); }
1640 #line 263 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1641 { RET_TOK(OtherOpVal, ICmp, ICMP); }
16541642 YY_BREAK
16551643 case 73:
16561644 YY_RULE_SETUP
1657 #line 264 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1658 { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
1645 #line 264 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1646 { RET_TOK(OtherOpVal, FCmp, FCMP); }
16591647 YY_BREAK
16601648 case 74:
16611649 YY_RULE_SETUP
1662 #line 265 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1663 { RET_TOK(BinaryOpVal, SetLT, SETLT); }
1650 #line 265 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1651 { return EQ; }
16641652 YY_BREAK
16651653 case 75:
16661654 YY_RULE_SETUP
1667 #line 266 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1668 { RET_TOK(BinaryOpVal, SetGT, SETGT); }
1655 #line 266 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1656 { return NE; }
16691657 YY_BREAK
16701658 case 76:
16711659 YY_RULE_SETUP
1672 #line 267 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1673 { RET_TOK(BinaryOpVal, SetLE, SETLE); }
1660 #line 267 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1661 { return SLT; }
16741662 YY_BREAK
16751663 case 77:
16761664 YY_RULE_SETUP
1677 #line 268 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1678 { RET_TOK(BinaryOpVal, SetGE, SETGE); }
1665 #line 268 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1666 { return SGT; }
16791667 YY_BREAK
16801668 case 78:
16811669 YY_RULE_SETUP
1682 #line 269 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1683 { RET_TOK(OtherOpVal, ICmp, ICMP); }
1670 #line 269 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1671 { return SLE; }
16841672 YY_BREAK
16851673 case 79:
16861674 YY_RULE_SETUP
1687 #line 270 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1688 { RET_TOK(OtherOpVal, FCmp, FCMP); }
1675 #line 270 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1676 { return SGE; }
16891677 YY_BREAK
16901678 case 80:
16911679 YY_RULE_SETUP
1692 #line 271 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1693 { return EQ; }
1680 #line 271 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1681 { return ULT; }
16941682 YY_BREAK
16951683 case 81:
16961684 YY_RULE_SETUP
1697 #line 272 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1698 { return NE; }
1685 #line 272 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1686 { return UGT; }
16991687 YY_BREAK
17001688 case 82:
17011689 YY_RULE_SETUP
1702 #line 273 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1703 { return SLT; }
1690 #line 273 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1691 { return ULE; }
17041692 YY_BREAK
17051693 case 83:
17061694 YY_RULE_SETUP
1707 #line 274 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1708 { return SGT; }
1695 #line 274 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1696 { return UGE; }
17091697 YY_BREAK
17101698 case 84:
17111699 YY_RULE_SETUP
1712 #line 275 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1713 { return SLE; }
1700 #line 275 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1701 { return OEQ; }
17141702 YY_BREAK
17151703 case 85:
17161704 YY_RULE_SETUP
1717 #line 276 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1718 { return SGE; }
1705 #line 276 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1706 { return ONE; }
17191707 YY_BREAK
17201708 case 86:
17211709 YY_RULE_SETUP
1722 #line 277 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1723 { return ULT; }
1710 #line 277 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1711 { return OLT; }
17241712 YY_BREAK
17251713 case 87:
17261714 YY_RULE_SETUP
1727 #line 278 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1728 { return UGT; }
1715 #line 278 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1716 { return OGT; }
17291717 YY_BREAK
17301718 case 88:
17311719 YY_RULE_SETUP
1732 #line 279 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1733 { return ULE; }
1720 #line 279 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1721 { return OLE; }
17341722 YY_BREAK
17351723 case 89:
17361724 YY_RULE_SETUP
1737 #line 280 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1738 { return UGE; }
1725 #line 280 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1726 { return OGE; }
17391727 YY_BREAK
17401728 case 90:
17411729 YY_RULE_SETUP
1742 #line 281 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1743 { return OEQ; }
1730 #line 281 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1731 { return ORD; }
17441732 YY_BREAK
17451733 case 91:
17461734 YY_RULE_SETUP
1747 #line 282 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1748 { return ONE; }
1735 #line 282 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1736 { return UNO; }
17491737 YY_BREAK
17501738 case 92:
17511739 YY_RULE_SETUP
1752 #line 283 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1753 { return OLT; }
1740 #line 283 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1741 { return UEQ; }
17541742 YY_BREAK
17551743 case 93:
17561744 YY_RULE_SETUP
1757 #line 284 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1758 { return OGT; }
1745 #line 284 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1746 { return UNE; }
17591747 YY_BREAK
17601748 case 94:
17611749 YY_RULE_SETUP
1762 #line 285 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1763 { return OLE; }
1750 #line 286 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1751 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
17641752 YY_BREAK
17651753 case 95:
17661754 YY_RULE_SETUP
1767 #line 286 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1768 { return OGE; }
1755 #line 287 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1756 { RET_TOK(OtherOpVal, Call, CALL); }
17691757 YY_BREAK
17701758 case 96:
17711759 YY_RULE_SETUP
1772 #line 287 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1773 { return ORD; }
1760 #line 288 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1761 { RET_TOK(CastOpVal, Trunc, TRUNC); }
17741762 YY_BREAK
17751763 case 97:
17761764 YY_RULE_SETUP
1777 #line 288 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1778 { return UNO; }
1765 #line 289 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1766 { RET_TOK(CastOpVal, ZExt, ZEXT); }
17791767 YY_BREAK
17801768 case 98:
17811769 YY_RULE_SETUP
1782 #line 289 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1783 { return UEQ; }
1770 #line 290 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1771 { RET_TOK(CastOpVal, SExt, SEXT); }
17841772 YY_BREAK
17851773 case 99:
17861774 YY_RULE_SETUP
1787 #line 290 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1788 { return UNE; }
1775 #line 291 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1776 { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
17891777 YY_BREAK
17901778 case 100:
17911779 YY_RULE_SETUP
1792 #line 292 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1793 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
1780 #line 292 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1781 { RET_TOK(CastOpVal, FPExt, FPEXT); }
17941782 YY_BREAK
17951783 case 101:
17961784 YY_RULE_SETUP
1797 #line 293 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1798 { RET_TOK(OtherOpVal, Call, CALL); }
1785 #line 293 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1786 { RET_TOK(CastOpVal, UIToFP, UITOFP); }
17991787 YY_BREAK
18001788 case 102:
18011789 YY_RULE_SETUP
1802 #line 294 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1803 { RET_TOK(CastOpVal, Trunc, TRUNC); }
1790 #line 294 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1791 { RET_TOK(CastOpVal, SIToFP, SITOFP); }
18041792 YY_BREAK
18051793 case 103:
18061794 YY_RULE_SETUP
1807 #line 295 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1808 { RET_TOK(CastOpVal, ZExt, ZEXT); }
1795 #line 295 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1796 { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
18091797 YY_BREAK
18101798 case 104:
18111799 YY_RULE_SETUP
1812 #line 296 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1813 { RET_TOK(CastOpVal, SExt, SEXT); }
1800 #line 296 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1801 { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
18141802 YY_BREAK
18151803 case 105:
18161804 YY_RULE_SETUP
1817 #line 297 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1818 { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
1805 #line 297 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1806 { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
18191807 YY_BREAK
18201808 case 106:
18211809 YY_RULE_SETUP
1822 #line 298 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1823 { RET_TOK(CastOpVal, FPExt, FPEXT); }
1810 #line 298 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1811 { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
18241812 YY_BREAK
18251813 case 107:
18261814 YY_RULE_SETUP
1827 #line 299 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1828 { RET_TOK(CastOpVal, UIToFP, UITOFP); }
1815 #line 299 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1816 { RET_TOK(CastOpVal, BitCast, BITCAST); }
18291817 YY_BREAK
18301818 case 108:
18311819 YY_RULE_SETUP
1832 #line 300 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1833 { RET_TOK(CastOpVal, SIToFP, SITOFP); }
1820 #line 300 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1821 { RET_TOK(OtherOpVal, Select, SELECT); }
18341822 YY_BREAK
18351823 case 109:
18361824 YY_RULE_SETUP
1837 #line 301 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1838 { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
1825 #line 301 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1826 { RET_TOK(OtherOpVal, Shl, SHL); }
18391827 YY_BREAK
18401828 case 110:
18411829 YY_RULE_SETUP
1842 #line 302 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1843 { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
1830 #line 302 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1831 { RET_TOK(OtherOpVal, LShr, LSHR); }
18441832 YY_BREAK
18451833 case 111:
18461834 YY_RULE_SETUP
1847 #line 303 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1848 { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
1835 #line 303 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1836 { RET_TOK(OtherOpVal, AShr, ASHR); }
18491837 YY_BREAK
18501838 case 112:
18511839 YY_RULE_SETUP
1852 #line 304 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1853 { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
1840 #line 304 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1841 { RET_TOK(OtherOpVal, VAArg , VAARG); }
18541842 YY_BREAK
18551843 case 113:
18561844 YY_RULE_SETUP
1857 #line 305 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1858 { RET_TOK(CastOpVal, BitCast, BITCAST); }
1845 #line 305 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1846 { RET_TOK(TermOpVal, Ret, RET); }
18591847 YY_BREAK
18601848 case 114:
18611849 YY_RULE_SETUP
1862 #line 306 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1863 { RET_TOK(OtherOpVal, Select, SELECT); }
1850 #line 306 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1851 { RET_TOK(TermOpVal, Br, BR); }
18641852 YY_BREAK
18651853 case 115:
18661854 YY_RULE_SETUP
1867 #line 307 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1868 { RET_TOK(OtherOpVal, Shl, SHL); }
1855 #line 307 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1856 { RET_TOK(TermOpVal, Switch, SWITCH); }
18691857 YY_BREAK
18701858 case 116:
18711859 YY_RULE_SETUP
1872 #line 308 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1873 { RET_TOK(OtherOpVal, LShr, LSHR); }
1860 #line 308 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1861 { RET_TOK(TermOpVal, Invoke, INVOKE); }
18741862 YY_BREAK
18751863 case 117:
18761864 YY_RULE_SETUP
1877 #line 309 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1878 { RET_TOK(OtherOpVal, AShr, ASHR); }
1865 #line 309 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1866 { RET_TOK(TermOpVal, Unwind, UNWIND); }
18791867 YY_BREAK
18801868 case 118:
18811869 YY_RULE_SETUP
1882 #line 310 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1883 { RET_TOK(OtherOpVal, VAArg , VAARG); }
1870 #line 310 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1871 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
18841872 YY_BREAK
18851873 case 119:
18861874 YY_RULE_SETUP
1887 #line 311 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1888 { RET_TOK(TermOpVal, Ret, RET); }
1875 #line 312 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1876 { RET_TOK(MemOpVal, Malloc, MALLOC); }
18891877 YY_BREAK
18901878 case 120:
18911879 YY_RULE_SETUP
1892 #line 312 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1893 { RET_TOK(TermOpVal, Br, BR); }
1880 #line 313 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1881 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
18941882 YY_BREAK
18951883 case 121:
18961884 YY_RULE_SETUP
1897 #line 313 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1898 { RET_TOK(TermOpVal, Switch, SWITCH); }
1885 #line 314 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1886 { RET_TOK(MemOpVal, Free, FREE); }
18991887 YY_BREAK
19001888 case 122:
19011889 YY_RULE_SETUP
1902 #line 314 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1903 { RET_TOK(TermOpVal, Invoke, INVOKE); }
1890 #line 315 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1891 { RET_TOK(MemOpVal, Load, LOAD); }
19041892 YY_BREAK
19051893 case 123:
19061894 YY_RULE_SETUP
1907 #line 315 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1908 { RET_TOK(TermOpVal, Unwind, UNWIND); }
1895 #line 316 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1896 { RET_TOK(MemOpVal, Store, STORE); }
19091897 YY_BREAK
19101898 case 124:
19111899 YY_RULE_SETUP
1912 #line 316 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1913 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
1900 #line 317 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1901 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
19141902 YY_BREAK
19151903 case 125:
19161904 YY_RULE_SETUP
1917 #line 318 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1918 { RET_TOK(MemOpVal, Malloc, MALLOC); }
1905 #line 319 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1906 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
19191907 YY_BREAK
19201908 case 126:
19211909 YY_RULE_SETUP
1922 #line 319 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1923 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
1910 #line 320 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1911 { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
19241912 YY_BREAK
19251913 case 127:
19261914 YY_RULE_SETUP
1927 #line 320 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1928 { RET_TOK(MemOpVal, Free, FREE); }
1915 #line 321 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
1916 { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
19291917 YY_BREAK
19301918 case 128:
19311919 YY_RULE_SETUP
1932 #line 321 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1933 { RET_TOK(MemOpVal, Load, LOAD); }
1934 YY_BREAK
1935 case 129:
1936 YY_RULE_SETUP
1937 #line 322 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1938 { RET_TOK(MemOpVal, Store, STORE); }
1939 YY_BREAK
1940 case 130:
1941 YY_RULE_SETUP
1942 #line 323 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1943 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
1944 YY_BREAK
1945 case 131:
1946 YY_RULE_SETUP
1947 #line 325 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1948 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
1949 YY_BREAK
1950 case 132:
1951 YY_RULE_SETUP
1952 #line 326 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1953 { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
1954 YY_BREAK
1955 case 133:
1956 YY_RULE_SETUP
1957 #line 327 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1958 { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
1959 YY_BREAK
1960 case 134:
1961 YY_RULE_SETUP
1962 #line 330 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1920 #line 324 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
19631921 {
19641922 UnEscapeLexed(yytext+1);
19651923 llvmAsmlval.StrVal = strdup(yytext+1); // Skip %
19661924 return VAR_ID;
19671925 }
19681926 YY_BREAK
1969 case 135:
1970 YY_RULE_SETUP
1971 #line 335 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1927 case 129:
1928 YY_RULE_SETUP
1929 #line 329 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
19721930 {
19731931 yytext[strlen(yytext)-1] = 0; // nuke colon
19741932 UnEscapeLexed(yytext);
19761934 return LABELSTR;
19771935 }
19781936 YY_BREAK
1979 case 136:
1980 YY_RULE_SETUP
1981 #line 341 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1937 case 130:
1938 YY_RULE_SETUP
1939 #line 335 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
19821940 {
19831941 yytext[strlen(yytext)-2] = 0; // nuke colon, end quote
19841942 UnEscapeLexed(yytext+1);
19861944 return LABELSTR;
19871945 }
19881946 YY_BREAK
1989 case 137:
1990 YY_RULE_SETUP
1991 #line 348 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1947 case 131:
1948 YY_RULE_SETUP
1949 #line 342 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
19921950 { // Note that we cannot unescape a string constant here! The
19931951 // string constant might contain a \00 which would not be
19941952 // understood by the string stuff. It is valid to make a
19991957 return STRINGCONSTANT;
20001958 }
20011959 YY_BREAK
2002 case 138:
2003 YY_RULE_SETUP
2004 #line 359 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1960 case 132:
1961 YY_RULE_SETUP
1962 #line 353 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
20051963 { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
20061964 YY_BREAK
2007 case 139:
2008 YY_RULE_SETUP
2009 #line 360 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1965 case 133:
1966 YY_RULE_SETUP
1967 #line 354 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
20101968 {
20111969 uint64_t Val = atoull(yytext+1);
20121970 // +1: we have bigger negative range
20161974 return ESINT64VAL;
20171975 }
20181976 YY_BREAK
2019 case 140:
2020 YY_RULE_SETUP
2021 #line 368 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1977 case 134:
1978 YY_RULE_SETUP
1979 #line 362 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
20221980 {
20231981 llvmAsmlval.UInt64Val = HexIntToVal(yytext+3);
20241982 return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
20251983 }
20261984 YY_BREAK
2027 case 141:
2028 YY_RULE_SETUP
2029 #line 373 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1985 case 135:
1986 YY_RULE_SETUP
1987 #line 367 "/proj/llvm/llvm-3/lib/AsmParser/Lexer.l"
20301988 {
20311989 uint64_t Val = atoull(yytext+1);
20321990 if ((unsigned)Val != Val)
20351993 return UINTVAL;
20361994 }
20371995 YY_BREAK
2038