llvm.org GIT mirror llvm / 3da59db
For PR950: The long awaited CAST patch. This introduces 12 new instructions into LLVM to replace the cast instruction. Corresponding changes throughout LLVM are provided. This passes llvm-test, llvm/test, and SPEC CPUINT2000 with the exception of 175.vpr which fails only on a slight floating point output difference. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@31931 91177308-0d34-0410-b5e6-96231b3b80d8 Reid Spencer 12 years ago
105 changed file(s) with 7031 addition(s) and 3994 deletion(s). Raw diff Collapse all Expand all
2626 /// rewrite expressions in canonical form.
2727 ///
2828 /// Clients should create an instance of this class when rewriting is needed,
29 /// and destroying it when finished to allow the release of the associated
29 /// and destroy it when finished to allow the release of the associated
3030 /// memory.
3131 struct SCEVExpander : public SCEVVisitor {
3232 ScalarEvolution &SE;
114114
115115 Value *visitTruncateExpr(SCEVTruncateExpr *S) {
116116 Value *V = expand(S->getOperand());
117 return new CastInst(V, S->getType(), "tmp.", InsertPt);
117 return CastInst::createInferredCast(V, S->getType(), "tmp.", InsertPt);
118118 }
119119
120120 Value *visitZeroExtendExpr(SCEVZeroExtendExpr *S) {
121121 Value *V = expandInTy(S->getOperand(),S->getType()->getUnsignedVersion());
122 return new CastInst(V, S->getType(), "tmp.", InsertPt);
122 return CastInst::createInferredCast(V, S->getType(), "tmp.", InsertPt);
123123 }
124124
125125 Value *visitAddExpr(SCEVAddExpr *S) {
515515
516516 /// Cast constant expr
517517 ///
518 static Constant *getTrunc (Constant *C, const Type *Ty);
519 static Constant *getSignExtend (Constant *C, const Type *Ty);
520 static Constant *getZeroExtend (Constant *C, const Type *Ty);
521 static Constant *getFPTrunc (Constant *C, const Type *Ty);
522 static Constant *getFPExtend (Constant *C, const Type *Ty);
523 static Constant *getUIToFP (Constant *C, const Type *Ty);
524 static Constant *getSIToFP (Constant *C, const Type *Ty);
525 static Constant *getFPToUI (Constant *C, const Type *Ty);
526 static Constant *getFPToSI (Constant *C, const Type *Ty);
527 static Constant *getPtrToInt (Constant *C, const Type *Ty);
528 static Constant *getIntToPtr (Constant *C, const Type *Ty);
529 static Constant *getBitCast (Constant *C, const Type *Ty);
530
531 // @brief Convenience function for getting one of the casting operations
532 // using a CastOps opcode.
533 static Constant *getCast(
534 unsigned ops, ///< The opcode for the conversion
535 Constant *C, ///< The constant to be converted
536 const Type *Ty ///< The type to which the constant is converted
537 );
538
539 // @brief Get a ConstantExpr Conversion operator that casts C to Ty
518540 static Constant *getCast(Constant *C, const Type *Ty);
519 static Constant *getSignExtend(Constant *C, const Type *Ty);
520 static Constant *getZeroExtend(Constant *C, const Type *Ty);
541
542 /// @brief Return true if this is a convert constant expression
543 bool isCast() const;
544
521545
522546 /// Select constant expr
523547 ///
243243 };
244244
245245 //===----------------------------------------------------------------------===//
246 // CastInst Class
247 //===----------------------------------------------------------------------===//
248
249 /// CastInst - This is the base class for all instructions that perform data
250 /// casts. It is simply provided so that instruction category testing
251 /// can be performed with code like:
252 ///
253 /// if (isa(Instr)) { ... }
254 /// @brief Base class of casting instructions.
255 class CastInst : public UnaryInstruction {
256 /// @brief Copy constructor
257 CastInst(const CastInst &CI)
258 : UnaryInstruction(CI.getType(), CI.getOpcode(), CI.getOperand(0)) {
259 }
260 /// @brief Do not allow default construction
261 CastInst();
262 protected:
263 /// @brief Constructor with insert-before-instruction semantics for subclasses
264 CastInst(const Type *Ty, unsigned iType, Value *S,
265 const std::string &Name = "", Instruction *InsertBefore = 0)
266 : UnaryInstruction(Ty, iType, S, Name, InsertBefore) {
267 }
268 /// @brief Constructor with insert-at-end-of-block semantics for subclasses
269 CastInst(const Type *Ty, unsigned iType, Value *S,
270 const std::string &Name, BasicBlock *InsertAtEnd)
271 : UnaryInstruction(Ty, iType, S, Name, InsertAtEnd) {
272 }
273 public:
274 /// Provides a way to construct any of the CastInst subclasses using an
275 /// opcode instead of the subclass's constructor. The opcode must be in the
276 /// CastOps category (Instruction::isCast(opcode) returns true). This
277 /// constructor has insert-before-instruction semantics to automatically
278 /// insert the new CastInst before InsertBefore (if it is non-null).
279 /// @brief Construct any of the CastInst subclasses
280 static CastInst *create(
281 Instruction::CastOps, ///< The opcode of the cast instruction
282 Value *S, ///< The value to be casted (operand 0)
283 const Type *Ty, ///< The type to which cast should be made
284 const std::string &Name = "", ///< Name for the instruction
285 Instruction *InsertBefore = 0 ///< Place to insert the instruction
286 );
287 /// Provides a way to construct any of the CastInst subclasses using an
288 /// opcode instead of the subclass's constructor. The opcode must be in the
289 /// CastOps category. This constructor has insert-at-end-of-block semantics
290 /// to automatically insert the new CastInst at the end of InsertAtEnd (if
291 /// its non-null).
292 /// @brief Construct any of the CastInst subclasses
293 static CastInst *create(
294 Instruction::CastOps, ///< The opcode for the cast instruction
295 Value *S, ///< The value to be casted (operand 0)
296 const Type *Ty, ///< The type to which operand is casted
297 const std::string &Name, ///< The name for the instruction
298 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
299 );
300
301 /// Returns the opcode necessary to cast Val into Ty using usual casting
302 /// rules.
303 static Instruction::CastOps getCastOpcode(
304 const Value *Val, ///< The value to cast
305 const Type *Ty ///< The Type to which the value should be casted
306 );
307
308 /// Joins the create method (with insert-before-instruction semantics) above
309 /// with the getCastOpcode method. getOpcode(S,Ty) is called first to
310 /// obtain the opcode for casting S to type Ty. Then the get(...) method is
311 /// called to create the CastInst and insert it. The instruction is
312 /// inserted before InsertBefore (if it is non-null). The cast created is
313 /// inferred, because only the types involved are used in determining which
314 /// cast opcode to use. For specific casts, use one of the create methods.
315 /// @brief Inline helper method to join create with getCastOpcode.
316 inline static CastInst *createInferredCast(
317 Value *S, ///< The value to be casted (operand 0)
318 const Type *Ty, ///< Type to which operand should be casted
319 const std::string &Name = "", ///< Name for the instruction
320 Instruction *InsertBefore = 0 ///< Place to insert the CastInst
321 ) {
322 return create(getCastOpcode(S, Ty), S, Ty, Name, InsertBefore);
323 }
324
325 /// Joins the get method (with insert-at-end-of-block semantics) method
326 /// above with the getCastOpcode method. getOpcode(S,Ty) is called first to
327 /// obtain the usual casting opcode for casting S to type Ty. Then the
328 /// get(...) method is called to create the CastInst and insert it. The
329 /// instruction is inserted at the end of InsertAtEnd (if it is non-null).
330 /// The created cast is inferred, because only the types involved are used
331 /// in determining which cast opcode to use. For specific casts, use one of
332 /// the create methods.
333 /// @brief Inline helper method to join create with getCastOpcode.
334 inline static CastInst *createInferredCast(
335 Value *S, ///< The value to be casted (operand 0)
336 const Type *Ty, ///< Type to which operand should be casted
337 const std::string &Name, ///< Name for the instruction
338 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
339 ) {
340 return create(getCastOpcode(S, Ty), S, Ty, Name, InsertAtEnd);
341 }
342
343 /// There are several places where we need to know if a cast instruction
344 /// only deals with integer source and destination types. To simplify that
345 /// logic, this method is provided.
346 /// @returns true iff the cast has only integral typed operand and dest type.
347 /// @brief Determine if this is an integer-only cast.
348 bool isIntegerCast() const;
349
350 /// A lossless cast is one that does not alter the basic value. It implies
351 /// a no-op cast but is more stringent, preventing things like int->float,
352 /// long->double, int->ptr, or packed->anything.
353 /// @returns true iff the cast is lossless.
354 /// @brief Determine if this is a lossless cast.
355 bool isLosslessCast() const;
356
357 /// A no-op cast is one that can be effected without changing any bits.
358 /// It implies that the source and destination types are the same size. The
359 /// IntPtrTy argument is used to make accurate determinations for casts
360 /// involving Integer and Pointer types. They are no-op casts if the integer
361 /// is the same size as the pointer. However, pointer size varies with
362 /// platform. Generally, the result of TargetData::getIntPtrType() should be
363 /// passed in. If that's not available, use Type::ULongTy, which will make
364 /// the isNoopCast call conservative.
365 /// @brief Determine if this cast is a no-op cast.
366 bool isNoopCast(
367 const Type *IntPtrTy ///< Integer type corresponding to pointer
368 ) const;
369
370 /// Determine how a pair of casts can be eliminated, if they can be at all.
371 /// This is a helper function for both CastInst and ConstantExpr.
372 /// @returns 0 if the CastInst pair can't be eliminated
373 /// @returns Instruction::CastOps value for a cast that can replace
374 /// the pair, casting SrcTy to DstTy.
375 /// @brief Determine if a cast pair is eliminable
376 static unsigned isEliminableCastPair(
377 Instruction::CastOps firstOpcode, ///< Opcode of first cast
378 Instruction::CastOps secondOpcode, ///< Opcode of second cast
379 const Type *SrcTy, ///< SrcTy of 1st cast
380 const Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
381 const Type *DstTy, ///< DstTy of 2nd cast
382 const Type *IntPtrTy ///< Integer type corresponding to Ptr types
383 );
384
385 /// @brief Return the opcode of this CastInst
386 Instruction::CastOps getOpcode() const {
387 return Instruction::CastOps(Instruction::getOpcode());
388 }
389
390 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
391 static inline bool classof(const CastInst *) { return true; }
392 static inline bool classof(const Instruction *I) {
393 return I->getOpcode() >= CastOpsBegin && I->getOpcode() < CastOpsEnd;
394 }
395 static inline bool classof(const Value *V) {
396 return isa(V) && classof(cast(V));
397 }
398 };
399
400 //===----------------------------------------------------------------------===//
246401 // CmpInst Class
247402 //===----------------------------------------------------------------------===//
248403
5757 #endif
5858 #ifndef LAST_MEMORY_INST
5959 #define LAST_MEMORY_INST(num)
60 #endif
61
62 #ifndef FIRST_CAST_INST
63 #define FIRST_CAST_INST(num)
64 #endif
65 #ifndef HANDLE_CAST_INST
66 #ifndef HANDLE_INST
67 #define HANDLE_CAST_INST(num, opcode, Class)
68 #else
69 #define HANDLE_CAST_INST(num, opcode, Class) HANDLE_INST(num, opcode, Class)
70 #endif
71 #endif
72 #ifndef LAST_CAST_INST
73 #define LAST_CAST_INST(num)
6074 #endif
6175
6276 #ifndef FIRST_OTHER_INST
123137 HANDLE_MEMORY_INST(30, GetElementPtr, GetElementPtrInst)
124138 LAST_MEMORY_INST(30)
125139
140 // Cast operators ...
141 // NOTE: The order matters here because CastInst::isEliminableCastPair
142 // NOTE: (see Instructions.cpp) encodes a table based on this ordering.
143 FIRST_CAST_INST(31)
144 HANDLE_CAST_INST(31, Trunc , CastInst ) // Truncate integers
145 HANDLE_CAST_INST(32, ZExt , CastInst ) // Zero extend integers
146 HANDLE_CAST_INST(33, SExt , CastInst ) // Sign extend integers
147 HANDLE_CAST_INST(34, FPToUI , CastInst ) // floating point -> UInt
148 HANDLE_CAST_INST(35, FPToSI , CastInst ) // floating point -> SInt
149 HANDLE_CAST_INST(36, UIToFP , CastInst ) // UInt -> floating point
150 HANDLE_CAST_INST(37, SIToFP , CastInst ) // SInt -> floating point
151 HANDLE_CAST_INST(38, FPTrunc , CastInst ) // Truncate floating point
152 HANDLE_CAST_INST(39, FPExt , CastInst ) // Extend floating point
153 HANDLE_CAST_INST(40, PtrToInt, CastInst ) // Pointer -> Integer
154 HANDLE_CAST_INST(41, IntToPtr, CastInst ) // Integer -> Pointer
155 HANDLE_CAST_INST(42, BitCast , CastInst ) // Type cast
156 LAST_CAST_INST(42)
157
126158 // Other operators...
127 FIRST_OTHER_INST(31)
128 HANDLE_OTHER_INST(31, ICmp , ICmpInst ) // Integer comparison instruction
129 HANDLE_OTHER_INST(32, FCmp , FCmpInst ) // Floating point comparison instr.
130 HANDLE_OTHER_INST(33, PHI , PHINode ) // PHI node instruction
131 HANDLE_OTHER_INST(34, Cast , CastInst ) // Type cast
132 HANDLE_OTHER_INST(35, Call , CallInst ) // Call a function
133 HANDLE_OTHER_INST(36, Shl , ShiftInst ) // Shift Left operations (logical)
134 HANDLE_OTHER_INST(37, LShr , ShiftInst ) // Logical Shift right (unsigned)
135 HANDLE_OTHER_INST(38, AShr , ShiftInst ) // Arithmetic shift right (signed)
136 HANDLE_OTHER_INST(39, Select , SelectInst ) // select instruction
137 HANDLE_OTHER_INST(40, UserOp1, Instruction) // May be used internally in a pass
138 HANDLE_OTHER_INST(41, UserOp2, Instruction) // Internal to passes only
139 HANDLE_OTHER_INST(42, VAArg , VAArgInst ) // vaarg instruction
140 HANDLE_OTHER_INST(43, ExtractElement, ExtractElementInst)// extract from vector.
141 HANDLE_OTHER_INST(44, InsertElement, InsertElementInst) // insert into vector
142 HANDLE_OTHER_INST(45, ShuffleVector, ShuffleVectorInst) // shuffle two vectors.
143 LAST_OTHER_INST(45)
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)
144175
145176 #undef FIRST_TERM_INST
146177 #undef HANDLE_TERM_INST
154185 #undef HANDLE_MEMORY_INST
155186 #undef LAST_MEMORY_INST
156187
188 #undef FIRST_CAST_INST
189 #undef HANDLE_CAST_INST
190 #undef LAST_CAST_INST
191
157192 #undef FIRST_OTHER_INST
158193 #undef HANDLE_OTHER_INST
159194 #undef LAST_OTHER_INST
124124 return getOpcode() >= BinaryOpsBegin && getOpcode() < BinaryOpsEnd;
125125 }
126126
127 /// @brief Determine if the OpCode is one of the CastInst instructions.
128 static inline bool isCast(unsigned OpCode) {
129 return OpCode >= CastOpsBegin && OpCode < CastOpsEnd;
130 }
131
132 /// @brief Determine if this is one of the CastInst instructions.
133 inline bool isCast() const {
134 return isCast(getOpcode());
135 }
136
127137 /// isAssociative - Return true if the instruction is associative:
128138 ///
129139 /// Associative operators satisfy: x op (y op z) === (x op y) op z
190200 #include "llvm/Instruction.def"
191201 };
192202
203 enum CastOps {
204 #define FIRST_CAST_INST(N) CastOpsBegin = N,
205 #define HANDLE_CAST_INST(N, OPC, CLASS) OPC = N,
206 #define LAST_CAST_INST(N) CastOpsEnd = N+1
207 #include "llvm/Instruction.def"
208 };
209
193210 enum OtherOps {
194211 #define FIRST_OTHER_INST(N) OtherOpsBegin = N,
195212 #define HANDLE_OTHER_INST(N, OPC, CLASS) OPC = N,
709709 }
710710 };
711711
712 //===----------------------------------------------------------------------===//
713 // CastInst Class
714 //===----------------------------------------------------------------------===//
715
716 /// CastInst - This class represents a cast from Operand[0] to the type of
717 /// the instruction (i->getType()).
718 ///
719 class CastInst : public UnaryInstruction {
720 CastInst(const CastInst &CI)
721 : UnaryInstruction(CI.getType(), Cast, CI.getOperand(0)) {
722 }
723 public:
724 CastInst(Value *S, const Type *Ty, const std::string &Name = "",
725 Instruction *InsertBefore = 0)
726 : UnaryInstruction(Ty, Cast, S, Name, InsertBefore) {
727 }
728 CastInst(Value *S, const Type *Ty, const std::string &Name,
729 BasicBlock *InsertAtEnd)
730 : UnaryInstruction(Ty, Cast, S, Name, InsertAtEnd) {
731 }
732
733 /// isTruncIntCast - Return true if this is a truncating integer cast
734 /// instruction, e.g. a cast from long to uint.
735 bool isTruncIntCast() const;
736
737
738 virtual CastInst *clone() const;
739
740 // Methods for support type inquiry through isa, cast, and dyn_cast:
741 static inline bool classof(const CastInst *) { return true; }
742 static inline bool classof(const Instruction *I) {
743 return I->getOpcode() == Cast;
744 }
745 static inline bool classof(const Value *V) {
746 return isa(V) && classof(cast(V));
747 }
748 };
749
750712
751713 //===----------------------------------------------------------------------===//
752714 // CallInst Class
17691731 virtual void setSuccessorV(unsigned idx, BasicBlock *B);
17701732 };
17711733
1734 //===----------------------------------------------------------------------===//
1735 // TruncInst Class
1736 //===----------------------------------------------------------------------===//
1737
1738 /// @brief This class represents a truncation of integer types.
1739 class TruncInst : public CastInst {
1740 /// Private copy constructor
1741 TruncInst(const TruncInst &CI)
1742 : CastInst(CI.getType(), Trunc, CI.getOperand(0)) {
1743 }
1744 public:
1745 /// @brief Constructor with insert-before-instruction semantics
1746 TruncInst(
1747 Value *S, ///< The value to be truncated
1748 const Type *Ty, ///< The (smaller) type to truncate to
1749 const std::string &Name = "", ///< A name for the new instruction
1750 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
1751 );
1752
1753 /// @brief Constructor with insert-at-end-of-block semantics
1754 TruncInst(
1755 Value *S, ///< The value to be truncated
1756 const Type *Ty, ///< The (smaller) type to truncate to
1757 const std::string &Name, ///< A name for the new instruction
1758 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
1759 );
1760
1761 /// @brief Clone an identical TruncInst
1762 virtual CastInst *clone() const;
1763
1764 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1765 static inline bool classof(const TruncInst *) { return true; }
1766 static inline bool classof(const Instruction *I) {
1767 return I->getOpcode() == Trunc;
1768 }
1769 static inline bool classof(const Value *V) {
1770 return isa(V) && classof(cast(V));
1771 }
1772 };
1773
1774 //===----------------------------------------------------------------------===//
1775 // ZExtInst Class
1776 //===----------------------------------------------------------------------===//
1777
1778 /// @brief This class represents zero extension of integer types.
1779 class ZExtInst : public CastInst {
1780 /// @brief Private copy constructor
1781 ZExtInst(const ZExtInst &CI)
1782 : CastInst(CI.getType(), ZExt, CI.getOperand(0)) {
1783 }
1784 public:
1785 /// @brief Constructor with insert-before-instruction semantics
1786 ZExtInst(
1787 Value *S, ///< The value to be zero extended
1788 const Type *Ty, ///< The type to zero extend to
1789 const std::string &Name = "", ///< A name for the new instruction
1790 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
1791 );
1792
1793 /// @brief Constructor with insert-at-end semantics.
1794 ZExtInst(
1795 Value *S, ///< The value to be zero extended
1796 const Type *Ty, ///< The type to zero extend to
1797 const std::string &Name, ///< A name for the new instruction
1798 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
1799 );
1800
1801 /// @brief Clone an identical ZExtInst
1802 virtual CastInst *clone() const;
1803
1804 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1805 static inline bool classof(const ZExtInst *) { return true; }
1806 static inline bool classof(const Instruction *I) {
1807 return I->getOpcode() == ZExt;
1808 }
1809 static inline bool classof(const Value *V) {
1810 return isa(V) && classof(cast(V));
1811 }
1812 };
1813
1814 //===----------------------------------------------------------------------===//
1815 // SExtInst Class
1816 //===----------------------------------------------------------------------===//
1817
1818 /// @brief This class represents a sign extension of integer types.
1819 class SExtInst : public CastInst {
1820 /// @brief Private copy constructor
1821 SExtInst(const SExtInst &CI)
1822 : CastInst(CI.getType(), SExt, CI.getOperand(0)) {
1823 }
1824 public:
1825 /// @brief Constructor with insert-before-instruction semantics
1826 SExtInst(
1827 Value *S, ///< The value to be sign extended
1828 const Type *Ty, ///< The type to sign extend to
1829 const std::string &Name = "", ///< A name for the new instruction
1830 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
1831 );
1832
1833 /// @brief Constructor with insert-at-end-of-block semantics
1834 SExtInst(
1835 Value *S, ///< The value to be sign extended
1836 const Type *Ty, ///< The type to sign extend to
1837 const std::string &Name, ///< A name for the new instruction
1838 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
1839 );
1840
1841 /// @brief Clone an identical SExtInst
1842 virtual CastInst *clone() const;
1843
1844 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1845 static inline bool classof(const SExtInst *) { return true; }
1846 static inline bool classof(const Instruction *I) {
1847 return I->getOpcode() == SExt;
1848 }
1849 static inline bool classof(const Value *V) {
1850 return isa(V) && classof(cast(V));
1851 }
1852 };
1853
1854 //===----------------------------------------------------------------------===//
1855 // FPTruncInst Class
1856 //===----------------------------------------------------------------------===//
1857
1858 /// @brief This class represents a truncation of floating point types.
1859 class FPTruncInst : public CastInst {
1860 FPTruncInst(const FPTruncInst &CI)
1861 : CastInst(CI.getType(), FPTrunc, CI.getOperand(0)) {
1862 }
1863 public:
1864 /// @brief Constructor with insert-before-instruction semantics
1865 FPTruncInst(
1866 Value *S, ///< The value to be truncated
1867 const Type *Ty, ///< The type to truncate to
1868 const std::string &Name = "", ///< A name for the new instruction
1869 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
1870 );
1871
1872 /// @brief Constructor with insert-before-instruction semantics
1873 FPTruncInst(
1874 Value *S, ///< The value to be truncated
1875 const Type *Ty, ///< The type to truncate to
1876 const std::string &Name, ///< A name for the new instruction
1877 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
1878 );
1879
1880 /// @brief Clone an identical FPTruncInst
1881 virtual CastInst *clone() const;
1882
1883 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1884 static inline bool classof(const FPTruncInst *) { return true; }
1885 static inline bool classof(const Instruction *I) {
1886 return I->getOpcode() == FPTrunc;
1887 }
1888 static inline bool classof(const Value *V) {
1889 return isa(V) && classof(cast(V));
1890 }
1891 };
1892
1893 //===----------------------------------------------------------------------===//
1894 // FPExtInst Class
1895 //===----------------------------------------------------------------------===//
1896
1897 /// @brief This class represents an extension of floating point types.
1898 class FPExtInst : public CastInst {
1899 FPExtInst(const FPExtInst &CI)
1900 : CastInst(CI.getType(), FPExt, CI.getOperand(0)) {
1901 }
1902 public:
1903 /// @brief Constructor with insert-before-instruction semantics
1904 FPExtInst(
1905 Value *S, ///< The value to be extended
1906 const Type *Ty, ///< The type to extend to
1907 const std::string &Name = "", ///< A name for the new instruction
1908 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
1909 );
1910
1911 /// @brief Constructor with insert-at-end-of-block semantics
1912 FPExtInst(
1913 Value *S, ///< The value to be extended
1914 const Type *Ty, ///< The type to extend to
1915 const std::string &Name, ///< A name for the new instruction
1916 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
1917 );
1918
1919 /// @brief Clone an identical FPExtInst
1920 virtual CastInst *clone() const;
1921
1922 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1923 static inline bool classof(const FPExtInst *) { return true; }
1924 static inline bool classof(const Instruction *I) {
1925 return I->getOpcode() == FPExt;
1926 }
1927 static inline bool classof(const Value *V) {
1928 return isa(V) && classof(cast(V));
1929 }
1930 };
1931
1932 //===----------------------------------------------------------------------===//
1933 // UIToFPInst Class
1934 //===----------------------------------------------------------------------===//
1935
1936 /// @brief This class represents a cast unsigned integer to floating point.
1937 class UIToFPInst : public CastInst {
1938 UIToFPInst(const UIToFPInst &CI)
1939 : CastInst(CI.getType(), UIToFP, CI.getOperand(0)) {
1940 }
1941 public:
1942 /// @brief Constructor with insert-before-instruction semantics
1943 UIToFPInst(
1944 Value *S, ///< The value to be converted
1945 const Type *Ty, ///< The type to convert to
1946 const std::string &Name = "", ///< A name for the new instruction
1947 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
1948 );
1949
1950 /// @brief Constructor with insert-at-end-of-block semantics
1951 UIToFPInst(
1952 Value *S, ///< The value to be converted
1953 const Type *Ty, ///< The type to convert to
1954 const std::string &Name, ///< A name for the new instruction
1955 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
1956 );
1957
1958 /// @brief Clone an identical UIToFPInst
1959 virtual CastInst *clone() const;
1960
1961 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
1962 static inline bool classof(const UIToFPInst *) { return true; }
1963 static inline bool classof(const Instruction *I) {
1964 return I->getOpcode() == UIToFP;
1965 }
1966 static inline bool classof(const Value *V) {
1967 return isa(V) && classof(cast(V));
1968 }
1969 };
1970
1971 //===----------------------------------------------------------------------===//
1972 // SIToFPInst Class
1973 //===----------------------------------------------------------------------===//
1974
1975 /// @brief This class represents a cast from signed integer to floating point.
1976 class SIToFPInst : public CastInst {
1977 SIToFPInst(const SIToFPInst &CI)
1978 : CastInst(CI.getType(), SIToFP, CI.getOperand(0)) {
1979 }
1980 public:
1981 /// @brief Constructor with insert-before-instruction semantics
1982 SIToFPInst(
1983 Value *S, ///< The value to be converted
1984 const Type *Ty, ///< The type to convert to
1985 const std::string &Name = "", ///< A name for the new instruction
1986 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
1987 );
1988
1989 /// @brief Constructor with insert-at-end-of-block semantics
1990 SIToFPInst(
1991 Value *S, ///< The value to be converted
1992 const Type *Ty, ///< The type to convert to
1993 const std::string &Name, ///< A name for the new instruction
1994 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
1995 );
1996
1997 /// @brief Clone an identical SIToFPInst
1998 virtual CastInst *clone() const;
1999
2000 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2001 static inline bool classof(const SIToFPInst *) { return true; }
2002 static inline bool classof(const Instruction *I) {
2003 return I->getOpcode() == SIToFP;
2004 }
2005 static inline bool classof(const Value *V) {
2006 return isa(V) && classof(cast(V));
2007 }
2008 };
2009
2010 //===----------------------------------------------------------------------===//
2011 // FPToUIInst Class
2012 //===----------------------------------------------------------------------===//
2013
2014 /// @brief This class represents a cast from floating point to unsigned integer
2015 class FPToUIInst : public CastInst {
2016 FPToUIInst(const FPToUIInst &CI)
2017 : CastInst(CI.getType(), FPToUI, CI.getOperand(0)) {
2018 }
2019 public:
2020 /// @brief Constructor with insert-before-instruction semantics
2021 FPToUIInst(
2022 Value *S, ///< The value to be converted
2023 const Type *Ty, ///< The type to convert to
2024 const std::string &Name = "", ///< A name for the new instruction
2025 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2026 );
2027
2028 /// @brief Constructor with insert-at-end-of-block semantics
2029 FPToUIInst(
2030 Value *S, ///< The value to be converted
2031 const Type *Ty, ///< The type to convert to
2032 const std::string &Name, ///< A name for the new instruction
2033 BasicBlock *InsertAtEnd ///< Where to insert the new instruction
2034 );
2035
2036 /// @brief Clone an identical FPToUIInst
2037 virtual CastInst *clone() const;
2038
2039 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2040 static inline bool classof(const FPToUIInst *) { return true; }
2041 static inline bool classof(const Instruction *I) {
2042 return I->getOpcode() == FPToUI;
2043 }
2044 static inline bool classof(const Value *V) {
2045 return isa(V) && classof(cast(V));
2046 }
2047 };
2048
2049 //===----------------------------------------------------------------------===//
2050 // FPToSIInst Class
2051 //===----------------------------------------------------------------------===//
2052
2053 /// @brief This class represents a cast from floating point to signed integer.
2054 class FPToSIInst : public CastInst {
2055 FPToSIInst(const FPToSIInst &CI)
2056 : CastInst(CI.getType(), FPToSI, CI.getOperand(0)) {
2057 }
2058 public:
2059 /// @brief Constructor with insert-before-instruction semantics
2060 FPToSIInst(
2061 Value *S, ///< The value to be converted
2062 const Type *Ty, ///< The type to convert to
2063 const std::string &Name = "", ///< A name for the new instruction
2064 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2065 );
2066
2067 /// @brief Constructor with insert-at-end-of-block semantics
2068 FPToSIInst(
2069 Value *S, ///< The value to be converted
2070 const Type *Ty, ///< The type to convert to
2071 const std::string &Name, ///< A name for the new instruction
2072 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
2073 );
2074
2075 /// @brief Clone an identical FPToSIInst
2076 virtual CastInst *clone() const;
2077
2078 /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
2079 static inline bool classof(const FPToSIInst *) { return true; }
2080 static inline bool classof(const Instruction *I) {
2081 return I->getOpcode() == FPToSI;
2082 }
2083 static inline bool classof(const Value *V) {
2084 return isa(V) && classof(cast(V));
2085 }
2086 };
2087
2088 //===----------------------------------------------------------------------===//
2089 // IntToPtrInst Class
2090 //===----------------------------------------------------------------------===//
2091
2092 /// @brief This class represents a cast from an integer to a pointer.
2093 class IntToPtrInst : public CastInst {
2094 IntToPtrInst(const IntToPtrInst &CI)
2095 : CastInst(CI.getType(), IntToPtr, CI.getOperand(0)) {
2096 }
2097 public:
2098 /// @brief Constructor with insert-before-instruction semantics
2099 IntToPtrInst(
2100 Value *S, ///< The value to be converted
2101 const Type *Ty, ///< The type to convert to
2102 const std::string &Name = "", ///< A name for the new instruction
2103 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2104 );
2105
2106 /// @brief Constructor with insert-at-end-of-block semantics
2107 IntToPtrInst(
2108 Value *S, ///< The value to be converted
2109 const Type *Ty, ///< The type to convert to
2110 const std::string &Name, ///< A name for the new instruction
2111 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
2112 );
2113
2114 /// @brief Clone an identical IntToPtrInst
2115 virtual CastInst *clone() const;
2116
2117 // Methods for support type inquiry through isa, cast, and dyn_cast:
2118 static inline bool classof(const IntToPtrInst *) { return true; }
2119 static inline bool classof(const Instruction *I) {
2120 return I->getOpcode() == IntToPtr;
2121 }
2122 static inline bool classof(const Value *V) {
2123 return isa(V) && classof(cast(V));
2124 }
2125 };
2126
2127 //===----------------------------------------------------------------------===//
2128 // PtrToIntInst Class
2129 //===----------------------------------------------------------------------===//
2130
2131 /// @brief This class represents a cast from a pointer to an integer
2132 class PtrToIntInst : public CastInst {
2133 PtrToIntInst(const PtrToIntInst &CI)
2134 : CastInst(CI.getType(), PtrToInt, CI.getOperand(0)) {
2135 }
2136 public:
2137 /// @brief Constructor with insert-before-instruction semantics
2138 PtrToIntInst(
2139 Value *S, ///< The value to be converted
2140 const Type *Ty, ///< The type to convert to
2141 const std::string &Name = "", ///< A name for the new instruction
2142 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2143 );
2144
2145 /// @brief Constructor with insert-at-end-of-block semantics
2146 PtrToIntInst(
2147 Value *S, ///< The value to be converted
2148 const Type *Ty, ///< The type to convert to
2149 const std::string &Name, ///< A name for the new instruction
2150 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
2151 );
2152
2153 /// @brief Clone an identical PtrToIntInst
2154 virtual CastInst *clone() const;
2155
2156 // Methods for support type inquiry through isa, cast, and dyn_cast:
2157 static inline bool classof(const PtrToIntInst *) { return true; }
2158 static inline bool classof(const Instruction *I) {
2159 return I->getOpcode() == PtrToInt;
2160 }
2161 static inline bool classof(const Value *V) {
2162 return isa(V) && classof(cast(V));
2163 }
2164 };
2165
2166 //===----------------------------------------------------------------------===//
2167 // BitCastInst Class
2168 //===----------------------------------------------------------------------===//
2169
2170 /// @brief This class represents a no-op cast from one type to another.
2171 class BitCastInst : public CastInst {
2172 BitCastInst(const BitCastInst &CI)
2173 : CastInst(CI.getType(), BitCast, CI.getOperand(0)) {
2174 }
2175 public:
2176 /// @brief Constructor with insert-before-instruction semantics
2177 BitCastInst(
2178 Value *S, ///< The value to be casted
2179 const Type *Ty, ///< The type to casted to
2180 const std::string &Name = "", ///< A name for the new instruction
2181 Instruction *InsertBefore = 0 ///< Where to insert the new instruction
2182 );
2183
2184 /// @brief Constructor with insert-at-end-of-block semantics
2185 BitCastInst(
2186 Value *S, ///< The value to be casted
2187 const Type *Ty, ///< The type to casted to
2188 const std::string &Name, ///< A name for the new instruction
2189 BasicBlock *InsertAtEnd ///< The block to insert the instruction into
2190 );
2191
2192 /// @brief Clone an identical BitCastInst
2193 virtual CastInst *clone() const;
2194
2195 // Methods for support type inquiry through isa, cast, and dyn_cast:
2196 static inline bool classof(const BitCastInst *) { return true; }
2197 static inline bool classof(const Instruction *I) {
2198 return I->getOpcode() == BitCast;
2199 }
2200 static inline bool classof(const Value *V) {
2201 return isa(V) && classof(cast(V));
2202 }
2203 };
2204
17722205 } // End llvm namespace
17732206
17742207 #endif
141141 void visitModule (Module &M) {}
142142 void visitFunction (Function &F) {}
143143 void visitBasicBlock(BasicBlock &BB) {}
144
145144
146145 // Define instruction specific visitor functions that can be overridden to
147146 // handle SPECIFIC instructions. These functions automatically define
182181 RetTy visitCallInst(CallInst &I) { DELEGATE(Instruction); }
183182 RetTy visitShiftInst(ShiftInst &I) { DELEGATE(Instruction); }
184183 RetTy visitVAArgInst(VAArgInst &I) { DELEGATE(Instruction); }
185 RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction); }
184 RetTy visitExtractElementInst(ExtractElementInst &I) { DELEGATE(Instruction);}
186185 RetTy visitInsertElementInst(InsertElementInst &I) { DELEGATE(Instruction); }
187186 RetTy visitShuffleVectorInst(ShuffleVectorInst &I) { DELEGATE(Instruction); }
188187
99 // This file provides a simple and efficient mechanism for performing general
1010 // tree-based pattern matches on the LLVM IR. The power of these routines is
1111 // that it allows you to write concise patterns that are expressive and easy to
12 // understand. The other major advantage of this is that is allows to you
12 // understand. The other major advantage of this is that it allows you to
1313 // trivially capture/bind elements in the pattern to variables. For example,
1414 // you can do something like this:
1515 //
335335 inline not_match m_Not(const LHS &L) { return L; }
336336
337337
338 template
339 struct cast_match {
340 Op_t Op;
341 const Type **DestTy;
342
343 cast_match(const Op_t &op, const Type **destTy) : Op(op), DestTy(destTy) {}
344
345 template
346 bool match(OpTy *V) {
347 if (CastInst *I = dyn_cast(V)) {
348 if (DestTy) *DestTy = I->getType();
349 return Op.match(I->getOperand(0));
350 } else if (ConstantExpr *CE = dyn_cast(V)) {
351 if (CE->getOpcode() == Instruction::Cast) {
352 if (DestTy) *DestTy = CE->getType();
353 return Op.match(CE->getOperand(0));
354 }
355 }
356 return false;
357 }
358 };
359
360 template
361 inline cast_match m_Cast(const Op_t &Op, const Type *&Ty) {
362 return cast_match(Op, &Ty);
363 }
364 template
365 inline cast_match m_Cast(const Op_t &Op) {
366 return cast_match(Op, 0);
367 }
368
369
370338 //===----------------------------------------------------------------------===//
371339 // Matchers for control flow
372340 //
193193 ///
194194 inline bool isAbstract() const { return Abstract; }
195195
196 /// isLosslesslyConvertibleTo - Return true if this type can be converted to
197 /// 'Ty' without any reinterpretation of bits. For example, uint to int.
198 ///
199 bool isLosslesslyConvertibleTo(const Type *Ty) const;
196 /// canLosslesslyBitCastTo - Return true if this type could be converted
197 /// with a lossless BitCast to type 'Ty'. For example, uint to int. BitCasts
198 /// are valid for types of the same size only where no re-interpretation of
199 /// the bits is done.
200 /// @brief Determine if this type could be losslessly bitcast to Ty
201 bool canLosslesslyBitCastTo(const Type *Ty) const;
200202
201203
202204 /// Here are some useful little methods to query what type derived types are
128128 return new BasicAliasAnalysis();
129129 }
130130
131 // hasUniqueAddress - Return true if the specified value points to something
132 // with a unique, discernable, address.
133 static inline bool hasUniqueAddress(const Value *V) {
134 return isa(V) || isa(V);
135 }
136
137131 // getUnderlyingObject - This traverses the use chain to figure out what object
138132 // the specified value points to. If the value points to, or is derived from, a
139133 // unique object or an argument, return it.
140134 static const Value *getUnderlyingObject(const Value *V) {
141135 if (!isa(V->getType())) return 0;
142136
143 // If we are at some type of object... return it.
144 if (hasUniqueAddress(V) || isa(V)) return V;
137 // If we are at some type of object, return it. GlobalValues and Allocations
138 // have unique addresses.
139 if (isa(V) || isa(V) || isa(V))
140 return V;
145141
146142 // Traverse through different addressing mechanisms...
147143 if (const Instruction *I = dyn_cast(V)) {
148 if (isa<CastInst>(I) || isa(I))
144 if (isa<BitCastInst>(I) || isa(I))
149145 return getUnderlyingObject(I->getOperand(0));
150146 } else if (const ConstantExpr *CE = dyn_cast(V)) {
151 if (CE->getOpcode() == Instruction::Cast ||
147 if (CE->getOpcode() == Instruction::BitCast ||
152148 CE->getOpcode() == Instruction::GetElementPtr)
153149 return getUnderlyingObject(CE->getOperand(0));
154150 }
191187 return false;
192188 }
193189
190 // Determine if an AllocationInst instruction escapes from the function it is
191 // contained in. If it does not escape, there is no way for another function to
192 // mod/ref it. We do this by looking at its uses and determining if the uses
193 // can escape (recursively).
194194 static bool AddressMightEscape(const Value *V) {
195195 for (Value::use_const_iterator UI = V->use_begin(), E = V->use_end();
196196 UI != E; ++UI) {
197197 const Instruction *I = cast(*UI);
198198 switch (I->getOpcode()) {
199 case Instruction::Load: break;
199 case Instruction::Load:
200 break; //next use.
200201 case Instruction::Store:
201202 if (I->getOperand(0) == V)
202203 return true; // Escapes if the pointer is stored.
203 break;
204 break; // next use.
204205 case Instruction::GetElementPtr:
205 if (AddressMightEscape(I)) return true;
206 break;
207 case Instruction::Cast:
206 if (AddressMightEscape(I))
207 return true;
208 case Instruction::BitCast:
208209 if (!isa(I->getType()))
209210 return true;
210 if (AddressMightEscape(I)) return true;
211 break;
211 if (AddressMightEscape(I))
212 return true;
213 break; // next use
212214 case Instruction::Ret:
213215 // If returned, the address will escape to calling functions, but no
214216 // callees could modify it.
215 break;
217 break; // next use
216218 default:
217219 return true;
218220 }
256258 const Value *V2, unsigned V2Size) {
257259 // Strip off any constant expression casts if they exist
258260 if (const ConstantExpr *CE = dyn_cast(V1))
259 if (CE->getOpcode() == Instruction::Cast &&
260 isa(CE->getOperand(0)->getType()))
261 if (CE->isCast() && isa(CE->getOperand(0)->getType()))
261262 V1 = CE->getOperand(0);
262263 if (const ConstantExpr *CE = dyn_cast(V2))
263 if (CE->getOpcode() == Instruction::Cast &&
264 isa(CE->getOperand(0)->getType()))
264 if (CE->isCast() && isa(CE->getOperand(0)->getType()))
265265 V2 = CE->getOperand(0);
266266
267267 // Are we checking for alias of the same value?
272272 return NoAlias; // Scalars cannot alias each other
273273
274274 // Strip off cast instructions...
275 if (const Instruction *I = dyn_cast<CastInst>(V1))
275 if (const BitCastInst *I = dyn_castCastInst>(V1))
276276 if (isa(I->getOperand(0)->getType()))
277277 return alias(I->getOperand(0), V1Size, V2, V2Size);
278 if (const Instruction *I = dyn_cast<CastInst>(V2))
278 if (const BitCastInst *I = dyn_castCastInst>(V2))
279279 if (isa(I->getOperand(0)->getType()))
280280 return alias(V1, V1Size, I->getOperand(0), V2Size);
281281
449449 return MayAlias;
450450 }
451451
452 static bool ValuesEqual(Value *V1, Value *V2) {
452 // This function is used to determin if the indices of two GEP instructions are
453 // equal. V1 and V2 are the indices.
454 static bool IndexOperandsEqual(Value *V1, Value *V2) {
453455 if (V1->getType() == V2->getType())
454456 return V1 == V2;
455457 if (Constant *C1 = dyn_cast(V1))
456458 if (Constant *C2 = dyn_cast(V2)) {
457 // Sign extend the constants to long types.
458 C1 = ConstantExpr::getSignExtend(C1, Type::LongTy);
459 C2 = ConstantExpr::getSignExtend(C2, Type::LongTy);
459 // Sign extend the constants to long types, if necessary
460 if (C1->getType()->getPrimitiveSizeInBits() < 64)
461 C1 = ConstantExpr::getSignExtend(C1, Type::LongTy);
462 else if (C1->getType() == Type::ULongTy)
463 C1 = ConstantExpr::getBitCast(C1, Type::LongTy);
464 if (C2->getType()->getPrimitiveSizeInBits() < 64)
465 C2 = ConstantExpr::getSignExtend(C2, Type::LongTy);
466 else if (C2->getType() == Type::ULongTy)
467 C2 = ConstantExpr::getBitCast(C2, Type::LongTy);
460468 return C1 == C2;
461469 }
462470 return false;
484492 unsigned MaxOperands = std::max(NumGEP1Operands, NumGEP2Operands);
485493 unsigned UnequalOper = 0;
486494 while (UnequalOper != MinOperands &&
487 ValuesEqual(GEP1Ops[UnequalOper], GEP2Ops[UnequalOper])) {
495 IndexOperandsEqual(GEP1Ops[UnequalOper], GEP2Ops[UnequalOper])) {
488496 // Advance through the type as we go...
489497 ++UnequalOper;
490498 if (const CompositeType *CT = dyn_cast(BasePtr1Ty))
545553 if (Constant *G2OC = dyn_cast(const_cast(G2Oper))){
546554 if (G1OC->getType() != G2OC->getType()) {
547555 // Sign extend both operands to long.
548 G1OC = ConstantExpr::getSignExtend(G1OC, Type::LongTy);
549 G2OC = ConstantExpr::getSignExtend(G2OC, Type::LongTy);
556 if (G1OC->getType()->getPrimitiveSizeInBits() < 64)
557 G1OC = ConstantExpr::getSignExtend(G1OC, Type::LongTy);
558 else if (G1OC->getType() == Type::ULongTy)
559 G1OC = ConstantExpr::getBitCast(G1OC, Type::LongTy);
560 if (G2OC->getType()->getPrimitiveSizeInBits() < 64)
561 G2OC = ConstantExpr::getSignExtend(G2OC, Type::LongTy);
562 else if (G2OC->getType() == Type::ULongTy)
563 G2OC = ConstantExpr::getBitCast(G2OC, Type::LongTy);
550564 GEP1Ops[FirstConstantOper] = G1OC;
551565 GEP2Ops[FirstConstantOper] = G2OC;
552566 }
409409
410410 const Type *T1 = T1W.getCurrentType();
411411 const Type *T2 = T2W.getCurrentType();
412 if (T1 != T2 && !T1->isLosslesslyConvertibleTo(T2))
412 if (T1 != T2 && !T1->canLosslesslyBitCastTo(T2))
413413 return false;
414414
415415 T1W.StepToNextType();
700700 // Check to see if we have a compatible, but different type...
701701 if (NewTySize == SubTypeSize) {
702702 // Check to see if this type is obviously convertible... int -> uint f.e.
703 if (NewTy->isLosslesslyConvertibleTo(SubType))
703 if (NewTy->canLosslesslyBitCastTo(SubType))
704704 return false;
705705
706706 // Check to see if we have a pointer & integer mismatch going on here,
239239 N->addGlobal(GV);
240240 } else if (Constant *C = dyn_cast(V)) {
241241 if (ConstantExpr *CE = dyn_cast(C)) {
242 if (CE->getOpcode() == Instruction::Cast) {
242 if (CE->isCast()) {
243243 if (isa(CE->getOperand(0)->getType()))
244244 NH = getValueDest(*CE->getOperand(0));
245245 else
10901090
10911091 /// Handle casts...
10921092 void GraphBuilder::visitCastInst(CastInst &CI) {
1093 if (isPointerType(CI.getType()))
1094 if (isPointerType(CI.getOperand(0)->getType())) {
1095 DSNodeHandle Ptr = getValueDest(*CI.getOperand(0));
1096 if (Ptr.getNode() == 0) return;
1097
1098 // Cast one pointer to the other, just act like a copy instruction
1099 setDestTo(CI, Ptr);
1100 } else {
1101 // Cast something (floating point, small integer) to a pointer. We need
1102 // to track the fact that the node points to SOMETHING, just something we
1103 // don't know about. Make an "Unknown" node.
1104 //
1105 setDestTo(CI, createNode()->setUnknownNodeMarker());
1106 }
1093 // Pointers can only be cast with BitCast so check that the instruction
1094 // is a BitConvert. If not, its guaranteed not to involve any pointers so
1095 // we don't do anything.
1096 switch (CI.getOpcode()) {
1097 default: break;
1098 case Instruction::BitCast:
1099 case Instruction::IntToPtr:
1100 if (isPointerType(CI.getType()))
1101 if (isPointerType(CI.getOperand(0)->getType())) {
1102 DSNodeHandle Ptr = getValueDest(*CI.getOperand(0));
1103 if (Ptr.getNode() == 0) return;
1104 // Cast one pointer to the other, just act like a copy instruction
1105 setDestTo(CI, Ptr);
1106 } else {
1107 // Cast something (floating point, small integer) to a pointer. We
1108 // need to track the fact that the node points to SOMETHING, just
1109 // something we don't know about. Make an "Unknown" node.
1110 setDestTo(CI, createNode()->setUnknownNodeMarker());
1111 }
1112 break;
1113 }
11071114 }
11081115
11091116
528528 switch (CE->getOpcode()) {
529529 case Instruction::GetElementPtr:
530530 return getNodeForConstantPointer(CE->getOperand(0));
531 case Instruction::Cast:
532 if (isa(CE->getOperand(0)->getType()))
533 return getNodeForConstantPointer(CE->getOperand(0));
534 else
535 return &GraphNodes[UniversalSet];
531 case Instruction::IntToPtr:
532 return &GraphNodes[UniversalSet];
533 case Instruction::BitCast:
534 return getNodeForConstantPointer(CE->getOperand(0));
536535 default:
537536 std::cerr << "Constant Expr not yet handled: " << *CE << "\n";
538537 assert(0);
556555 switch (CE->getOpcode()) {
557556 case Instruction::GetElementPtr:
558557 return getNodeForConstantPointerTarget(CE->getOperand(0));
559 case Instruction::Cast:
560 if (isa(CE->getOperand(0)->getType()))
561 return getNodeForConstantPointerTarget(CE->getOperand(0));
562 else
563 return &GraphNodes[UniversalSet];
558 case Instruction::IntToPtr:
559 return &GraphNodes[UniversalSet];
560 case Instruction::BitCast:
561 return getNodeForConstantPointerTarget(CE->getOperand(0));
564562 default:
565563 std::cerr << "Constant Expr not yet handled: " << *CE << "\n";
566564 assert(0);
166166
167167 // Traverse through different addressing mechanisms.
168168 if (Instruction *I = dyn_cast(V)) {
169 if (isa<CastInst>(I) || isa(I))
169 if (isa<BitCastInst>(I) || isa(I))
170170 return getUnderlyingObject(I->getOperand(0));
171171 } else if (ConstantExpr *CE = dyn_cast(V)) {
172 if (CE->getOpcode() == Instruction::Cast ||
172 if (CE->getOpcode() == Instruction::BitCast ||
173173 CE->getOpcode() == Instruction::GetElementPtr)
174174 return getUnderlyingObject(CE->getOperand(0));
175175 }
251251 for (unsigned i = 3, e = II->getNumOperands(); i != e; ++i)
252252 if (II->getOperand(i) == V) return true;
253253 } else if (ConstantExpr *CE = dyn_cast(*UI)) {
254 if (CE->getOpcode() == Instruction::GetElementPtr ||
255 CE->getOpcode() == Instruction::Cast) {
254 if (CE->getOpcode() == Instruction::GetElementPtr ||
255 CE->getOpcode() == Instruction::BitCast) {
256256 if (AnalyzeUsesOfPointer(CE, Readers, Writers))
257257 return true;
258258 } else {
202202 SCEVTruncateExpr::SCEVTruncateExpr(const SCEVHandle &op, const Type *ty)
203203 : SCEV(scTruncate), Op(op), Ty(ty) {
204204 assert(Op->getType()->isInteger() && Ty->isInteger() &&
205 Ty->isUnsigned() &&
206205 "Cannot truncate non-integer value!");
207206 assert(Op->getType()->getPrimitiveSize() > Ty->getPrimitiveSize() &&
208207 "This is not a truncating conversion!");
229228 SCEVZeroExtendExpr::SCEVZeroExtendExpr(const SCEVHandle &op, const Type *ty)
230229 : SCEV(scZeroExtend), Op(op), Ty(ty) {
231230 assert(Op->getType()->isInteger() && Ty->isInteger() &&
232 Ty->isUnsigned() &&
233231 "Cannot zero extend non-integer value!");
234232 assert(Op->getType()->getPrimitiveSize() < Ty->getPrimitiveSize() &&
235233 "This is not an extending conversion!");
11381136 /// createSCEV - We know that there is no SCEV for the specified value.
11391137 /// Analyze the expression.
11401138 SCEVHandle createSCEV(Value *V);
1141 SCEVHandle createNodeForCast(CastInst *CI);
11421139
11431140 /// createNodeForPHI - Provide the special handling we need to analyze PHI
11441141 /// SCEVs.
13401337 return SCEVUnknown::get(PN);
13411338 }
13421339
1343 /// createNodeForCast - Handle the various forms of casts that we support.
1344 ///
1345 SCEVHandle ScalarEvolutionsImpl::createNodeForCast(CastInst *CI) {
1346 const Type *SrcTy = CI->getOperand(0)->getType();
1347 const Type *DestTy = CI->getType();
1348
1349 // If this is a noop cast (ie, conversion from int to uint), ignore it.
1350 if (SrcTy->isLosslesslyConvertibleTo(DestTy))
1351 return getSCEV(CI->getOperand(0));
1352
1353 if (SrcTy->isInteger() && DestTy->isInteger()) {
1354 // Otherwise, if this is a truncating integer cast, we can represent this
1355 // cast.
1356 if (SrcTy->getPrimitiveSize() > DestTy->getPrimitiveSize())
1357 return SCEVTruncateExpr::get(getSCEV(CI->getOperand(0)),
1358 CI->getType()->getUnsignedVersion());
1359 if (SrcTy->isUnsigned() &&
1360 SrcTy->getPrimitiveSize() <= DestTy->getPrimitiveSize())
1361 return SCEVZeroExtendExpr::get(getSCEV(CI->getOperand(0)),
1362 CI->getType()->getUnsignedVersion());
1363 }
1364
1365 // If this is an sign or zero extending cast and we can prove that the value
1366 // will never overflow, we could do similar transformations.
1367
1368 // Otherwise, we can't handle this cast!
1369 return SCEVUnknown::get(CI);
1370 }
1371
13721340
13731341 /// createSCEV - We know that there is no SCEV for the specified value.
13741342 /// Analyze the expression.
14001368 }
14011369 break;
14021370
1403 case Instruction::Cast:
1404 return createNodeForCast(cast(I));
1371 case Instruction::Trunc:
1372 if (I->getType()->isInteger() && I->getOperand(0)->getType()->isInteger())
1373 return SCEVTruncateExpr::get(getSCEV(I->getOperand(0)),
1374 I->getType()->getUnsignedVersion());
1375 break;
1376
1377 case Instruction::ZExt:
1378 if (I->getType()->isInteger() && I->getOperand(0)->getType()->isInteger())
1379 return SCEVZeroExtendExpr::get(getSCEV(I->getOperand(0)),
1380 I->getType()->getUnsignedVersion());
1381 break;
1382
1383 case Instruction::BitCast:
1384 // BitCasts are no-op casts so we just eliminate the cast.
1385 return getSCEV(I->getOperand(0));
14051386
14061387 case Instruction::PHI:
14071388 return createNodeForPHI(cast(I));
17231704 if (isa(I) || isa(I))
17241705 return ConstantExpr::get(I->getOpcode(), Operands[0], Operands[1]);
17251706
1707 if (isa(I))
1708 return ConstantExpr::getCast(I->getOpcode(), Operands[0], I->getType());
1709
17261710 switch (I->getOpcode()) {
1727 case Instruction::Cast:
1728 return ConstantExpr::getCast(Operands[0], I->getType());
17291711 case Instruction::Select:
17301712 return ConstantExpr::getSelect(Operands[0], Operands[1], Operands[2]);
17311713 case Instruction::Call:
17331715 Operands.erase(Operands.begin());
17341716 return ConstantFoldCall(cast(GV), Operands);
17351717 }
1736
17371718 return 0;
17381719 case Instruction::GetElementPtr:
17391720 Constant *Base = Operands[0];
2929 UI != E; ++UI) {
3030 if ((*UI)->getType() == Ty)
3131 if (CastInst *CI = dyn_cast(cast(*UI))) {
32 // If the cast isn't in the first instruction of the function,
33 // move it.
32 // If the cast isn't the first instruction of the function, move it.
3433 if (BasicBlock::iterator(CI) !=
3534 A->getParent()->getEntryBlock().begin()) {
3635 CI->moveBefore(A->getParent()->getEntryBlock().begin());
3837 return CI;
3938 }
4039 }
41 return new CastInst(V, Ty, V->getName(),
42 A->getParent()->getEntryBlock().begin());
40 return CastInst::createInferredCast(V, Ty, V->getName(),
41 A->getParent()->getEntryBlock().begin());
4342 }
4443
4544 Instruction *I = cast(V);
6463 if (InvokeInst *II = dyn_cast(I))
6564 IP = II->getNormalDest()->begin();
6665 while (isa(IP)) ++IP;
67 return new CastInst(V, Ty, V->getName(), IP);
66 return CastInst::createInferredCast(V, Ty, V->getName(), IP);
6867 }
6968
7069 Value *SCEVExpander::visitMulExpr(SCEVMulExpr *S) {
112112 for (Value::use_iterator UI = Op->use_begin(), UE = Op->use_end();
113113 UI != UE; ++UI)
114114 if (CastInst *Other = dyn_cast(*UI))
115 // Check that the types are the same, since this code handles casts...
116 if (Other->getType() == I.getType() &&
115 // Check that the opcode is the same
116 if (Other->getOpcode() == Instruction::CastOps(I.getOpcode()) &&
117 // Check that the destination types are the same
118 Other->getType() == I.getType() &&
117119 // Is it embedded in the same function? (This could be false if LHS
118120 // is a constant or global!)
119121 Other->getParent()->getParent() == F &&
1616 #define yylineno llvmAsmlineno
1717
1818 #line 20 "Lexer.cpp"
19 /* A lexical scanner generated by flex */
19 /* A lexical scanner generated by flex*/
2020
2121 /* Scanner skeleton version:
2222 * $Header$
2727 #define YY_FLEX_MINOR_VERSION 5
2828
2929 #include
30 #include
3031
3132
3233 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
4041 #ifdef __cplusplus
4142
4243 #include
43 #include
4444
4545 /* Use prototypes in function declarations. */
4646 #define YY_USE_PROTOS
151151 while ( 0 )
152152
153153 #define unput(c) yyunput( c, yytext_ptr )
154
155 /* Some routines like yy_flex_realloc() are emitted as static but are
156 not called by all lexers. This generates warnings in some compilers,
157 notably GCC. Arrange to suppress these. */
158 #ifdef __GNUC__
159 #define YY_MAY_BE_UNUSED __attribute__((unused))
160 #else
161 #define YY_MAY_BE_UNUSED
162 #endif
154163
155164 /* The following is because we cannot portably get our hands on size_t
156165 * (without autoconf's help, which isn't available because we want
258267 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
259268
260269 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
261 static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
270 static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t )) YY_MAY_BE_UNUSED;
262271 static void yy_flex_free YY_PROTO(( void * ));
263272
264273 #define yy_new_buffer yy_create_buffer
307316 *yy_cp = '\0'; \
308317 yy_c_buf_p = yy_cp;
309318
310 #define YY_NUM_RULES 120
311 #define YY_END_OF_BUFFER 121
312 static yyconst short int yy_acclist[198] =
319 #define YY_NUM_RULES 134
320 #define YY_END_OF_BUFFER 135
321 static yyconst short int yy_acclist[212] =
313322 { 0,
314 121, 119, 120, 118, 119, 120, 118, 120, 119, 120,
315 119, 120, 119, 120, 119, 120, 119, 120, 119, 120,
316 111, 119, 120, 111, 119, 120, 1, 119, 120, 119,
317 120, 119, 120, 119, 120, 119, 120, 119, 120, 119,
318 120, 119, 120, 119, 120, 119, 120, 119, 120, 119,
319 120, 119, 120, 119, 120, 119, 120, 119, 120, 119,
320 120, 119, 120, 119, 120, 119, 120, 119, 120, 119,
321 120, 110, 108, 107, 107, 114, 112, 116, 111, 1,
322 93, 41, 75, 23, 110, 107, 107, 115, 116, 20,
323 116, 117, 63, 74, 39, 34, 42, 66, 3, 54,
324
325 65, 25, 83, 70, 92, 87, 88, 64, 76, 109,
326 116, 116, 49, 84, 85, 69, 100, 73, 101, 56,
327 22, 113, 68, 72, 26, 4, 61, 67, 55, 71,
328 48, 11, 116, 36, 2, 5, 58, 60, 50, 78,
329 82, 80, 81, 79, 77, 52, 102, 51, 57, 21,
330 90, 99, 45, 59, 30, 24, 44, 7, 95, 33,
331 98, 38, 62, 86, 94, 27, 28, 96, 53, 91,
332 89, 43, 6, 29, 37, 8, 17, 9, 10, 35,
333 12, 14, 13, 32, 40, 15, 31, 97, 103, 105,
334 106, 16, 46, 104, 18, 47, 19
335
323 135, 133, 134, 132, 133, 134, 132, 134, 133, 134,
324 133, 134, 133, 134, 133, 134, 133, 134, 133, 134,
325 125, 133, 134, 125, 133, 134, 1, 133, 134, 133,
326 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
327 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
328 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
329 134, 133, 134, 133, 134, 133, 134, 133, 134, 133,
330 134, 124, 122, 121, 121, 128, 126, 130, 125, 1,
331 107, 41, 75, 23, 124, 121, 121, 129, 130, 20,
332 130, 131, 63, 74, 39, 34, 42, 66, 3, 54,
333
334 65, 25, 83, 70, 106, 99, 100, 64, 76, 123,
335 130, 130, 102, 49, 84, 85, 69, 114, 73, 115,
336 56, 101, 22, 127, 68, 88, 72, 26, 4, 61,
337 67, 55, 71, 48, 11, 87, 130, 36, 2, 5,
338 58, 90, 60, 50, 78, 82, 80, 81, 79, 77,
339 52, 116, 86, 51, 57, 21, 104, 113, 45, 59,
340 30, 24, 44, 94, 93, 7, 109, 33, 112, 38,
341 62, 98, 92, 108, 27, 28, 91, 110, 53, 105,
342 103, 97, 43, 6, 29, 89, 37, 8, 17, 9,
343 95, 10, 96, 35, 12, 14, 13, 32, 40, 15,
344
345 31, 111, 117, 119, 120, 16, 46, 118, 18, 47,
346 19
336347 } ;
337348
338 static yyconst short int yy_accept[527] =
349 static yyconst short int yy_accept[577] =
339350 { 0,
340351 1, 1, 1, 2, 4, 7, 9, 11, 13, 15,
341352 17, 19, 21, 24, 27, 30, 32, 34, 36, 38,
345356 81, 81, 81, 81, 81, 81, 81, 81, 81, 82,
346357 82, 83, 83, 83, 83, 83, 83, 83, 83, 83,
347358 83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
348 83, 83, 83, 83, 83, 83, 83, 83, 84, 84,
359 83, 83, 83, 83, 83, 83, 83, 83, 83, 83,
349360 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
350361
351 84, 84, 84, 85, 85, 85, 85, 85, 85, 85,
352 85, 85, 85, 85, 85, 85, 85, 85, 85, 86,
353 87, 89, 90, 91, 92, 92, 93, 94, 94, 94,
354 95, 95, 96, 96, 97, 97, 97, 97, 98, 98,
355 98, 98, 98, 98, 98, 99, 99, 99, 100, 100,
356 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
357 101, 101, 101, 101, 101, 101, 101, 101, 101, 102,
358 103, 103, 103, 104, 104, 105, 106, 106, 106, 106,
362 84, 84, 84, 84, 84, 84, 85, 85, 85, 85,
363 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
364 85, 85, 86, 87, 89, 90, 91, 92, 92, 93,
365 94, 94, 94, 95, 95, 95, 96, 96, 97, 97,
366 97, 97, 97, 98, 98, 98, 98, 98, 98, 98,
367 99, 99, 99, 100, 100, 100, 100, 100, 100, 100,
368 100, 100, 100, 100, 100, 100, 100, 101, 101, 101,
369 101, 101, 101, 101, 101, 101, 101, 102, 103, 103,
370 103, 104, 104, 104, 105, 106, 106, 106, 106, 106,
359371 106, 106, 106, 107, 107, 108, 108, 108, 108, 108,
372
373 108, 109, 109, 109, 109, 109, 109, 109, 109, 109,
360374 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
361
362 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
363 109, 109, 109, 109, 110, 110, 111, 112, 112, 112,
364 112, 113, 113, 113, 113, 113, 114, 115, 116, 116,
365 116, 116, 116, 116, 116, 116, 116, 116, 116, 116,
366 116, 116, 116, 116, 117, 117, 118, 119, 119, 119,
367 119, 119, 119, 119, 119, 119, 119, 120, 121, 121,
368 121, 122, 122, 122, 123, 123, 124, 124, 124, 124,
369 124, 124, 124, 124, 124, 124, 125, 125, 125, 126,
370 126, 126, 127, 128, 128, 129, 130, 130, 130, 130,
371 130, 130, 131, 131, 131, 131, 131, 132, 132, 133,
372
373 133, 133, 134, 135, 135, 135, 136, 136, 136, 136,
374 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
375 137, 137, 138, 138, 138, 138, 138, 138, 138, 139,
376 139, 139, 139, 139, 139, 139, 140, 140, 140, 141,
377 142, 143, 144, 145, 146, 147, 147, 147, 148, 148,
378 148, 148, 149, 150, 151, 151, 151, 151, 151, 151,
379 152, 152, 152, 152, 152, 152, 153, 153, 154, 154,
380 154, 154, 154, 154, 154, 154, 155, 156, 157, 157,
381 157, 158, 158, 159, 159, 159, 159, 160, 160, 161,
382 162, 163, 164, 164, 164, 165, 165, 165, 166, 167,
383
384 168, 168, 168, 169, 170, 171, 172, 172, 172, 172,
385 172, 172, 172, 173, 173, 174, 175, 175, 175, 175,
386 175, 175, 175, 175, 175, 175, 175, 175, 176, 176,
387 176, 176, 176, 176, 176, 176, 176, 176, 177, 177,
388 177, 177, 177, 178, 178, 178, 178, 178, 179, 180,
389 180, 180, 180, 180, 180, 181, 181, 181, 181, 182,
390 182, 183, 184, 184, 184, 184, 184, 184, 184, 184,
391 184, 184, 184, 184, 184, 184, 185, 185, 185, 185,
392 185, 185, 185, 185, 186, 186, 186, 186, 186, 186,
393 187, 187, 187, 187, 187, 188, 188, 188, 189, 189,
394
395 189, 189, 189, 189, 189, 189, 189, 189, 189, 189,
396 189, 189, 190, 190, 191, 192, 193, 193, 194, 194,
397 195, 196, 197, 197, 198, 198
375 109, 109, 109, 109, 109, 109, 110, 110, 110, 111,
376 112, 112, 112, 112, 113, 113, 113, 113, 114, 114,
377 114, 115, 116, 117, 117, 117, 117, 117, 117, 117,
378 117, 117, 117, 117, 117, 117, 117, 117, 117, 118,
379 118, 118, 118, 118, 119, 120, 120, 120, 120, 120,
380 120, 120, 120, 120, 120, 120, 121, 122, 123, 123,
381 123, 124, 124, 124, 124, 125, 125, 126, 126, 126,
382 126, 126, 126, 126, 127, 127, 127, 127, 127, 128,
383
384 128, 128, 129, 129, 129, 130, 130, 131, 131, 132,
385 133, 133, 133, 133, 133, 133, 133, 134, 134, 134,
386 134, 134, 135, 135, 136, 136, 136, 137, 138, 139,
387 139, 139, 140, 140, 140, 140, 140, 140, 140, 140,
388 140, 140, 140, 140, 140, 140, 140, 141, 141, 142,
389 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
390 143, 144, 144, 144, 144, 144, 144, 144, 144, 145,
391 145, 145, 146, 147, 148, 149, 150, 151, 152, 152,
392 152, 152, 153, 153, 153, 153, 154, 155, 155, 156,
393 157, 157, 157, 157, 157, 157, 158, 158, 158, 158,
394
395 158, 158, 159, 159, 159, 160, 160, 160, 160, 160,
396 160, 160, 160, 161, 162, 163, 163, 163, 164, 165,
397 166, 166, 166, 167, 167, 167, 167, 167, 168, 168,
398 169, 170, 171, 172, 172, 172, 172, 173, 173, 173,
399 174, 175, 176, 177, 178, 178, 178, 179, 180, 181,
400 182, 182, 182, 182, 182, 182, 183, 183, 184, 184,
401 185, 186, 186, 186, 186, 186, 186, 187, 187, 187,
402 187, 187, 187, 187, 187, 187, 188, 188, 188, 188,
403 188, 188, 188, 188, 188, 188, 189, 189, 189, 189,
404 189, 190, 190, 190, 190, 190, 191, 192, 193, 193,
405
406 194, 194, 194, 194, 194, 195, 195, 195, 195, 196,
407 196, 197, 198, 198, 198, 198, 198, 198, 198, 198,
408 198, 198, 198, 198, 198, 198, 199, 199, 199, 199,
409 199, 199, 199, 199, 200, 200, 200, 200, 200, 200,
410 201, 201, 201, 201, 201, 202, 202, 202, 203, 203,
411 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
412 203, 203, 204, 204, 205, 206, 207, 207, 208, 208,
413 209, 210, 211, 211, 212, 212
398414 } ;
399415
400416 static yyconst int yy_ec[256] =
438454 3, 3, 3
439455 } ;
440456
441 static yyconst short int yy_base[531] =
457 static yyconst short int yy_base[581] =
442458 { 0,
443 0, 0, 1140, 1141, 1141, 1141, 1135, 1124, 36, 40,
459 0, 0, 1240, 1241, 1241, 1241, 1235, 1224, 36, 40,
444460 44, 50, 56, 62, 0, 63, 66, 81, 89, 47,
445461 100, 97, 76, 96, 111, 49, 113, 110, 68, 140,
446 126, 171, 119, 118, 139, 133, 1133, 1141, 1122, 1141,
447 0, 176, 184, 199, 204, 70, 209, 224, 229, 0,
448 117, 130, 150, 72, 160, 151, 159, 123, 1121, 230,
449 178, 31, 69, 168, 240, 95, 233, 165, 241, 243,
450 242, 156, 244, 246, 187, 251, 253, 254, 211, 258,
451 256, 263, 260, 265, 190, 267, 283, 1120, 271, 274,
452 270, 285, 289, 290, 291, 292, 294, 295, 297, 299,
453
454 296, 308, 1119, 311, 300, 318, 320, 322, 323, 330,
455 325, 328, 327, 337, 342, 216, 336, 345, 1118, 0,
456 362, 366, 1117, 380, 397, 0, 1116, 370, 349, 1115,
457 373, 1114, 355, 1113, 371, 372, 384, 1112, 392, 326,
458 399, 398, 401, 402, 1111, 405, 404, 406, 411, 412,
459 409, 413, 415, 422, 423, 425, 424, 426, 428, 429,
460 435, 442, 374, 443, 444, 445, 446, 447, 1110, 1109,
461 448, 449, 1108, 450, 1107, 1106, 476, 454, 455, 464,
462 459, 488, 1105, 470, 1104, 490, 489, 460, 492, 1103,
463 493, 494, 495, 496, 501, 502, 504, 507, 508, 512,
464
465 514, 517, 519, 520, 521, 518, 457, 522, 526, 530,
466 539, 540, 541, 1102, 524, 1141, 550, 564, 568, 572,
467 577, 578, 458, 579, 580, 1101, 1100, 1099, 581, 582,
468 583, 584, 550, 585, 525, 586, 589, 551, 590, 587,
469 607, 591, 594, 1098, 592, 1097, 1096, 603, 611, 610,
470 593, 613, 617, 620, 621, 622, 1095, 1094, 623, 625,
471 1093, 624, 626, 0, 627, 1092, 629, 638, 630, 643,
472 644, 646, 628, 647, 654, 1091, 656, 661, 1090, 660,
473 658, 1089, 1088, 662, 1087, 1086, 659, 664, 672, 675,
474 676, 1085, 677, 678, 679, 681, 1084, 682, 1083, 684,
475
476 683, 690, 1082, 692, 695, 1081, 700, 704, 710, 711,
477 691, 713, 701, 702, 714, 715, 718, 722, 724, 1080,
478 726, 1079, 725, 727, 728, 729, 730, 736, 1078, 737,
479 740, 743, 746, 748, 751, 1077, 735, 738, 1076, 1075,
480 1074, 1073, 1072, 1071, 1070, 756, 758, 1069, 762, 759,
481 763, 1068, 1067, 1066, 764, 766, 767, 765, 769, 1065,
482 770, 776, 778, 777, 779, 1064, 781, 1063, 784, 785,
483 786, 790, 791, 797, 798, 1062, 1061, 1060, 802, 795,
484 1059, 803, 1058, 808, 811, 804, 1057, 805, 1056, 1055,
485 1054, 1053, 810, 821, 1052, 823, 824, 1051, 1050, 1049,
486
487 822, 825, 1048, 1047, 1046, 1045, 826, 827, 828, 829,
488 830, 833, 1044, 839, 1043, 1042, 840, 843, 844, 845,
489 846, 850, 848, 851, 852, 853, 854, 1041, 858, 863,
490 868, 869, 871, 875, 877, 878, 879, 1040, 881, 885,
491 886, 882, 1037, 887, 889, 888, 894, 1028, 1026, 897,
492 895, 892, 900, 907, 1025, 912, 916, 914, 1024, 917,
493 1023, 1021, 918, 920, 922, 925, 926, 924, 928, 931,
494 933, 932, 934, 936, 938, 1020, 941, 944, 937, 948,
495 949, 950, 952, 1019, 957, 961, 962, 963, 964, 1018,
496 965, 966, 967, 968, 1013, 969, 972, 1010, 973, 976,
497
498 982, 984, 990, 991, 992, 993, 994, 996, 997, 998,
499 999, 1006, 1000, 896, 893, 633, 1005, 632, 1007, 385,
500 354, 353, 1008, 301, 1141, 1043, 1045, 226, 1049, 166
462 126, 171, 120, 130, 124, 141, 1233, 1241, 1222, 1241,
463 0, 159, 176, 199, 204, 70, 209, 224, 229, 0,
464 137, 165, 143, 72, 169, 159, 230, 215, 1221, 168,
465 182, 31, 69, 187, 240, 191, 242, 243, 244, 248,
466 246, 245, 251, 254, 256, 249, 260, 262, 264, 211,
467 273, 274, 270, 280, 275, 284, 285, 288, 292, 1220,
468 293, 294, 298, 300, 301, 276, 302, 310, 311, 313,
469
470 305, 309, 312, 330, 331, 1219, 334, 320, 322, 338,
471 340, 324, 341, 346, 348, 361, 356, 359, 162, 353,
472 368, 1218, 0, 383, 387, 1217, 401, 418, 0, 1216,
473 376, 370, 1215, 393, 373, 1214, 392, 1213, 406, 407,
474 408, 403, 1212, 419, 95, 420, 372, 409, 421, 1211,
475 425, 431, 428, 430, 433, 435, 432, 440, 443, 444,
476 445, 451, 447, 446, 449, 450, 453, 461, 468, 458,
477 469, 470, 473, 474, 475, 480, 1210, 1209, 481, 482,
478 1208, 483, 485, 1207, 1206, 513, 491, 488, 494, 489,
479 524, 503, 1205, 486, 1204, 487, 525, 527, 250, 528,
480
481 1203, 506, 531, 532, 536, 542, 538, 530, 537, 540,
482 548, 544, 556, 550, 560, 557, 375, 554, 568, 558,
483 571, 493, 576, 564, 582, 1202, 574, 552, 1241, 591,
484 605, 609, 613, 618, 619, 577, 620, 1201, 621, 591,
485 1200, 1199, 1198, 622, 623, 624, 625, 626, 628, 627,
486 632, 630, 634, 633, 635, 644, 642, 643, 1197, 653,
487 655, 657, 658, 1196, 1195, 659, 660, 661, 662, 663,
488 667, 583, 671, 669, 673, 1194, 1193, 1192, 672, 677,
489 1191, 675, 666, 680, 0, 691, 1190, 693, 694, 695,
490 696, 702, 703, 1189, 697, 585, 704, 707, 1188, 709,
491
492 714, 1187, 722, 708, 1186, 726, 1185, 727, 1184, 1183,
493 724, 728, 730, 716, 732, 735, 1182, 738, 741, 742,
494 743, 1181, 744, 1180, 746, 745, 1179, 751, 1178, 755,
495 757, 1177, 751, 754, 764, 771, 772, 763, 499, 766,
496 774, 779, 775, 776, 780, 782, 1176, 783, 1175, 1174,
497 781, 787, 786, 795, 791, 796, 798, 801, 805, 802,
498 1173, 808, 807, 810, 813, 814, 819, 820, 1172, 809,
499 815, 1171, 1170, 1169, 1168, 1167, 1166, 1165, 826, 829,
500 830, 1164, 831, 832, 835, 1163, 1162, 834, 1161, 1160,
501 836, 840, 837, 842, 846, 1159, 848, 850, 851, 852,
502
503 860, 1158, 854, 858, 1157, 861, 862, 864, 870, 866,
504 868, 872, 1156, 1155, 1154, 880, 873, 1153, 1152, 1151,
505 876, 882, 1150, 891, 893, 889, 874, 1149, 899, 1148,
506 1147, 1146, 1145, 887, 895, 901, 1144, 904, 905, 1143,
507 1142, 1141, 1140, 1139, 903, 907, 1138, 1137, 1136, 1135,
508 909, 910, 914, 917, 911, 1134, 920, 1133, 921, 1132,
509 1131, 923, 925, 926, 927, 929, 1130, 931, 933, 934,
510 936, 935, 945, 937, 941, 1129, 947, 948, 953, 955,
511 961, 962, 966, 963, 965, 1128, 967, 969, 971, 968,
512 1127, 974, 978, 975, 979, 1126, 1123, 1113, 980, 1112,
513
514 981, 996, 982, 999, 1111, 1000, 1001, 1002, 1109, 987,
515 1108, 1107, 1004, 1008, 1011, 1013, 1012, 1014, 1016, 1019,
516 1020, 1021, 1022, 1024, 1025, 1104, 1026, 1029, 1031, 1032,
517 1035, 1037, 1038, 1101, 1041, 1047, 1048, 1049, 1051, 1100,
518 1053, 1052, 1054, 1057, 1098, 1058, 1059, 1096, 1065, 1071,
519 1060, 1069, 1072, 1077, 1079, 1082, 1081, 1083, 1084, 1085,
520 1087, 984, 1088, 983, 710, 668, 1092, 664, 1097, 593,
521 345, 214, 1094, 213, 1241, 1129, 1131, 187, 1135, 138
501522 } ;
502523
503 static yyconst short int yy_def[531] =
524 static yyconst short int yy_def[581] =
504525 { 0,
505 525, 1, 525, 525, 525, 525, 526, 527, 528, 525,
506 527, 527, 527, 527, 529, 527, 527, 527, 527, 527,
507 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
508 527, 527, 527, 527, 527, 527, 526, 525, 527, 525,
509 530, 530, 525, 525, 527, 527, 527, 527, 527, 529,
510 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
511 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
512 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
513 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
514 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
515
516 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
517 527, 527, 527, 527, 527, 527, 527, 527, 525, 530,
518 530, 525, 527, 527, 527, 49, 527, 527, 527, 527,
519 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
520 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
521 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
522 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
523 527, 527, 527, 527, 527, 527, 49, 527, 527, 527,
524 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
525 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
526
527 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
528 527, 527, 527, 527, 527, 525, 525, 525, 525, 527,
529 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
530 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
531 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
532 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
533 527, 527, 527, 177, 527, 527, 527, 527, 527, 527,
534 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
535 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
536 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
537
538 527, 525, 527, 527, 527, 527, 527, 527, 527, 527,
539 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
540 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
541 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
542 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
543 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
544 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
545 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
546 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
547 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
548
549 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
550 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
551 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
552 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
553 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
554 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
555 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
556 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
557 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
558 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
559
560 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
561 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
562 527, 527, 527, 527, 0, 525, 525, 525, 525, 525
526 575, 1, 575, 575, 575, 575, 576, 577, 578, 575,
527 577, 577, 577, 577, 579, 577, 577, 577, 577, 577,
528 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
529 577, 577, 577, 577, 577, 577, 576, 575, 577, 575,
530 580, 580, 575, 575, 577, 577, 577, 577, 577, 579,
531 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
532 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
533 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
534 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
535 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
536
537 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
538 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
539 577, 575, 580, 580, 575, 577, 577, 577, 49, 577,
540 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
541 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
542 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
543 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
544 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
545 577, 577, 577, 577, 577, 49, 577, 577, 577, 577,
546 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
547
548 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
549 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
550 577, 577, 577, 577, 577, 577, 577, 577, 575, 575,
551 575, 575, 577, 577, 577, 577, 577, 577, 577, 577,
552 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
553 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
554 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
555 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
556 577, 577, 577, 577, 186, 577, 577, 577, 577, 577,
557 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
558
559 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
560 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
561 577, 577, 577, 577, 577, 577, 577, 575, 577, 577,
562 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
563 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
564 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
565 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
566 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
567 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
568 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
569
570 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
571 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
572 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
573 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
574 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
575 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
576 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
577 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
578 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
579 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
580
581 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
582 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
583 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
584 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
585 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
586 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
587 577, 577, 577, 577, 577, 577, 577, 577, 577, 577,
588 577, 577, 577, 577, 0, 575, 575, 575, 575, 575
563589 } ;
564590
565 static yyconst short int yy_nxt[1185] =
591 static yyconst short int yy_nxt[1285] =
566592 { 0,
567593 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
568594 14, 14, 14, 4, 15, 8, 8, 8, 16, 17,
569595 18, 19, 20, 21, 22, 8, 23, 8, 24, 25,
570596 26, 27, 28, 8, 29, 30, 31, 32, 33, 34,
571597 35, 8, 36, 42, 40, 43, 43, 43, 43, 44,
572 44, 44, 44, 45, 45, 45, 45, 40, 46, 139,
573 40, 140, 40, 40, 47, 48, 48, 48, 48, 40,
574 47, 48, 48, 48, 48, 40, 40, 69, 123, 40,
575 85, 40, 40, 40, 51, 40, 86, 70, 56, 40,
576 91, 52, 57, 53, 40, 54, 49, 58, 55, 60,
577
578 59, 61, 40, 141, 131, 77, 78, 64, 40, 40,
579 40, 65, 62, 40, 79, 66, 63, 67, 71, 75,
580 68, 72, 80, 40, 40, 76, 40, 81, 73, 82,
581 40, 40, 40, 145, 74, 89, 40, 113, 127, 40,
582 115, 90, 83, 40, 102, 87, 40, 88, 84, 92,
583 114, 116, 40, 40, 135, 118, 128, 103, 129, 93,
584 104, 94, 95, 40, 40, 96, 97, 105, 120, 40,
585 117, 130, 40, 40, 98, 133, 99, 100, 40, 101,
586 92, 40, 153, 134, 40, 121, 121, 121, 121, 132,
587 106, 40, 107, 43, 43, 43, 43, 108, 138, 109,
588
589 40, 110, 147, 40, 142, 111, 112, 122, 44, 44,
590 44, 44, 47, 45, 45, 45, 45, 40, 124, 124,
591 124, 124, 40, 156, 40, 125, 170, 213, 41, 40,
592 162, 125, 47, 48, 48, 48, 48, 40, 126, 126,
593 126, 126, 40, 40, 126, 126, 40, 126, 126, 126,
594 126, 126, 126, 40, 40, 40, 40, 40, 136, 40,
595 143, 146, 148, 149, 40, 137, 40, 40, 155, 40,
596 151, 40, 144, 40, 165, 154, 40, 152, 40, 150,
597 40, 168, 157, 40, 40, 158, 166, 40, 163, 159,
598 160, 167, 161, 169, 164, 171, 40, 173, 40, 175,
599
600 174, 172, 40, 40, 40, 40, 176, 40, 40, 40,
601 40, 180, 40, 40, 40, 187, 179, 188, 190, 181,
602 183, 40, 191, 184, 40, 177, 185, 182, 189, 186,
603 178, 40, 196, 40, 192, 40, 40, 194, 40, 40,
604 40, 40, 193, 40, 207, 208, 198, 205, 195, 40,
605 40, 201, 199, 206, 200, 40, 202, 209, 40, 197,
606 212, 230, 40, 210, 203, 211, 40, 40, 40, 204,
607 214, 121, 121, 121, 121, 217, 217, 217, 217, 215,
608 223, 225, 218, 40, 40, 40, 40, 40, 218, 124,
609 124, 124, 124, 40, 222, 224, 125, 40, 40, 226,
610
611 227, 255, 125, 219, 220, 40, 221, 221, 221, 221,
612 40, 40, 40, 229, 40, 40, 232, 40, 40, 40,
613 228, 231, 40, 237, 40, 40, 40, 235, 40, 233,
614 234, 236, 238, 239, 240, 40, 40, 40, 40, 40,
615 245, 40, 40, 249, 242, 246, 241, 248, 40, 243,
616 251, 252, 247, 244, 250, 40, 40, 40, 40, 40,
617 40, 40, 40, 40, 254, 257, 253, 40, 40, 258,
618 40, 40, 40, 40, 259, 294, 261, 40, 304, 256,
619 263, 268, 262, 40, 260, 264, 264, 264, 264, 276,
620 265, 264, 264, 266, 264, 264, 264, 264, 264, 264,
621
622 267, 40, 40, 40, 273, 40, 40, 40, 40, 40,
623 269, 275, 270, 274, 40, 40, 271, 40, 272, 280,
624 40, 40, 279, 282, 283, 40, 277, 40, 281, 278,
625 40, 40, 40, 40, 40, 40, 288, 40, 40, 40,
626 284, 290, 287, 40, 286, 285, 291, 289, 296, 293,
627 292, 297, 40, 40, 40, 301, 295, 298, 300, 217,
628 217, 217, 217, 40, 40, 313, 218, 299, 311, 316,
629 219, 219, 218, 302, 302, 302, 302, 302, 302, 302,
630 302, 221, 221, 221, 221, 40, 221, 221, 221, 221,
631 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
632
633 40, 307, 40, 40, 40, 40, 40, 40, 303, 305,
634 306, 312, 310, 320, 321, 314, 40, 315, 308, 309,
635 40, 318, 317, 40, 40, 319, 40, 326, 322, 324,
636 40, 323, 325, 40, 40, 40, 40, 40, 40, 40,
637 40, 40, 40, 40, 328, 40, 40, 327, 329, 336,
638 331, 40, 330, 333, 332, 337, 40, 40, 338, 40,
639 40, 334, 335, 339, 345, 340, 342, 40, 344, 40,
640 346, 40, 40, 40, 40, 40, 347, 40, 348, 341,
641 343, 349, 350, 353, 352, 40, 351, 354, 40, 40,
642 40, 40, 40, 356, 40, 40, 40, 40, 355, 302,
643
644 302, 302, 302, 360, 40, 40, 357, 363, 40, 365,
645 366, 358, 359, 40, 40, 40, 367, 40, 362, 364,
646 368, 361, 369, 40, 40, 372, 40, 40, 40, 371,
647 370, 40, 373, 374, 375, 40, 376, 40, 40, 40,
648 40, 40, 40, 40, 380, 377, 381, 382, 40, 40,
649 40, 40, 379, 40, 378, 383, 40, 384, 387, 40,
650 386, 40, 389, 390, 40, 385, 394, 388, 391, 40,
651 392, 40, 40, 393, 395, 40, 40, 40, 40, 40,
652 40, 397, 40, 40, 396, 400, 402, 398, 403, 40,
653 40, 40, 40, 405, 40, 399, 408, 40, 40, 40,
654
655 401, 404, 407, 40, 40, 413, 406, 411, 40, 410,
656 40, 40, 415, 409, 412, 40, 40, 40, 40, 419,
657 420, 40, 425, 40, 40, 426, 416, 414, 417, 418,
658 423, 421, 422, 424, 40, 40, 40, 40, 40, 40,
659 40, 40, 40, 40, 427, 429, 40, 430, 431, 435,
660 432, 428, 40, 40, 433, 436, 40, 40, 40, 40,
661 437, 40, 434, 40, 40, 40, 40, 40, 444, 438,
662 439, 40, 445, 443, 440, 449, 40, 441, 446, 447,
663 448, 40, 40, 442, 40, 452, 453, 454, 40, 450,
664 40, 40, 40, 455, 40, 40, 451, 457, 40, 40,
665
666 40, 40, 40, 459, 463, 40, 40, 40, 40, 40,
667 40, 456, 470, 40, 458, 464, 467, 469, 460, 465,
668 40, 461, 462, 468, 466, 40, 472, 40, 471, 40,
669 40, 40, 473, 40, 474, 40, 477, 40, 40, 40,
670 475, 40, 478, 480, 40, 40, 40, 40, 483, 40,
671 40, 40, 487, 476, 40, 481, 489, 40, 479, 485,
672 486, 40, 40, 40, 488, 40, 482, 484, 490, 492,
673 40, 494, 495, 491, 40, 40, 40, 40, 40, 40,
674 40, 40, 40, 498, 493, 40, 40, 502, 496, 40,
675 499, 500, 501, 504, 507, 40, 509, 40, 505, 497,
676
677 506, 508, 503, 40, 40, 40, 40, 40, 510, 40,
678 40, 40, 40, 40, 511, 516, 517, 518, 40, 40,
679 40, 40, 513, 40, 512, 522, 40, 515, 514, 523,
680 521, 40, 40, 40, 40, 520, 40, 40, 40, 40,
681 519, 40, 524, 37, 37, 37, 37, 39, 39, 50,
682 40, 50, 50, 40, 40, 40, 40, 40, 40, 40,
598 44, 44, 44, 45, 45, 45, 45, 40, 46, 144,
599 40, 145, 40, 40, 47, 48, 48, 48, 48, 40,
600 47, 48, 48, 48, 48, 40, 40, 69, 126, 40,
601 87, 40, 40, 40, 51, 40, 88, 70, 56, 40,
602 94, 52, 57, 53, 40, 54, 49, 58, 55, 60,
603
604 59, 61, 40, 146, 134, 78, 79, 64, 40, 40,
605 40, 65, 62, 40, 80, 66, 63, 67, 71, 76,
606 68, 72, 81, 40, 40, 77, 40, 82, 73, 84,
607 245, 83, 74, 40, 75, 91, 119, 40, 116, 40,
608 123, 92, 85, 40, 105, 89, 93, 90, 86, 95,
609 40, 117, 118, 40, 40, 120, 40, 106, 130, 96,
610 107, 97, 98, 121, 133, 99, 100, 108, 124, 124,
611 124, 124, 40, 225, 101, 40, 102, 103, 40, 104,
612 95, 40, 40, 137, 40, 43, 43, 43, 43, 41,
613 109, 131, 110, 132, 135, 40, 141, 111, 136, 112,
614
615 40, 113, 143, 142, 40, 114, 115, 125, 44, 44,
616 44, 44, 47, 45, 45, 45, 45, 40, 127, 127,
617 127, 127, 40, 147, 40, 128, 40, 40, 40, 150,
618 169, 128, 47, 48, 48, 48, 48, 40, 129, 129,
619 129, 129, 40, 40, 129, 129, 140, 129, 129, 129,
620 129, 129, 129, 40, 138, 40, 40, 40, 40, 40,
621 148, 40, 40, 40, 40, 153, 139, 40, 154, 40,
622 151, 158, 149, 40, 156, 40, 160, 40, 162, 299,
623 152, 157, 159, 40, 155, 163, 40, 40, 40, 40,
624 161, 164, 172, 40, 165, 174, 176, 40, 40, 166,
625
626 167, 40, 168, 170, 173, 40, 40, 40, 175, 171,
627 180, 40, 177, 40, 40, 40, 179, 187, 40, 181,
628 182, 178, 40, 40, 40, 40, 40, 199, 188, 184,
629 189, 201, 183, 40, 197, 40, 185, 40, 190, 193,
630 200, 186, 194, 40, 40, 195, 191, 40, 196, 198,
631 192, 40, 207, 40, 40, 212, 202, 203, 40, 40,
632 205, 40, 213, 208, 209, 204, 40, 214, 217, 40,
633 210, 206, 40, 218, 40, 215, 211, 224, 219, 220,
634 216, 40, 222, 40, 223, 40, 40, 226, 40, 40,
635 247, 221, 124, 124, 124, 124, 230, 230, 230, 230,
636
637 235, 236, 227, 231, 317, 40, 40, 238, 228, 231,
638 127, 127, 127, 127, 40, 237, 40, 128, 239, 40,
639 40, 40, 40, 128, 232, 233, 240, 234, 234, 234,
640 234, 40, 40, 40, 40, 241, 242, 248, 40, 243,
641 244, 40, 246, 40, 40, 40, 40, 250, 40, 249,
642 252, 251, 254, 40, 253, 255, 40, 40, 40, 40,
643 40, 260, 40, 40, 40, 267, 40, 256, 258, 266,
644 257, 40, 269, 264, 40, 270, 262, 268, 259, 263,
645 265, 40, 40, 40, 261, 274, 40, 40, 40, 271,
646 273, 276, 272, 40, 40, 40, 40, 277, 40, 40,
647
648 40, 40, 40, 279, 40, 275, 40, 40, 278, 281,
649 296, 289, 40, 283, 322, 282, 40, 280, 410, 40,
650 295, 284, 285, 285, 285, 285, 287, 286, 285, 285,
651 288, 285, 285, 285, 285, 285, 285, 40, 40, 294,
652 40, 40, 301, 40, 40, 40, 290, 297, 291, 40,
653 40, 40, 292, 40, 293, 40, 303, 40, 298, 302,
654 307, 40, 300, 40, 305, 40, 308, 40, 304, 40,
655 40, 40, 306, 40, 312, 309, 310, 40, 313, 311,
656 314, 40, 315, 316, 40, 318, 319, 40, 327, 40,
657 40, 324, 320, 321, 323, 40, 40, 330, 40, 325,
658
659 230, 230, 230, 230, 40, 326, 40, 231, 379, 333,
660 360, 232, 232, 231, 328, 328, 328, 328, 328, 328,
661 328, 328, 234, 234, 234, 234, 40, 234, 234, 234,
662 234, 40, 40, 40, 40, 40, 40, 40, 40, 40,
663 40, 40, 334, 40, 338, 40, 40, 40, 40, 329,
664 331, 332, 343, 337, 339, 40, 40, 40, 342, 335,
665 336, 341, 346, 348, 347, 344, 40, 340, 40, 345,
666 40, 40, 40, 40, 40, 40, 40, 40, 355, 40,
667 40, 40, 40, 356, 40, 40, 40, 354, 40, 349,
668 40, 350, 351, 40, 352, 353, 357, 358, 359, 361,
669
670 362, 363, 367, 364, 40, 365, 40, 40, 40, 40,
671 40, 368, 366, 369, 371, 40, 40, 40, 373, 370,
672 40, 40, 40, 40, 375, 377, 380, 40, 372, 40,
673 381, 382, 374, 378, 383, 40, 385, 40, 376, 40,
674 40, 40, 391, 40, 384, 40, 386, 388, 40, 387,
675 392, 40, 389, 390, 40, 40, 40, 40, 40, 40,
676 328, 328, 328, 328, 40, 393, 396, 40, 40, 399,
677 40, 401, 394, 402, 405, 395, 40, 40, 403, 40,
678 398, 400, 406, 397, 40, 40, 404, 40, 40, 40,
679 408, 407, 40, 40, 40, 40, 40, 409, 411, 40,
680
681 40, 413, 417, 418, 40, 414, 412, 419, 40, 40,
682 416, 40, 415, 420, 40, 40, 421, 422, 40, 423,
683 40, 40, 40, 40, 428, 424, 40, 40, 40, 430,
684 431, 426, 40, 40, 425, 432, 433, 427, 429, 40,
685 436, 434, 40, 40, 40, 40, 435, 40, 40, 40,
686 40, 437, 439, 40, 438, 40, 441, 443, 447, 40,
687 446, 40, 440, 40, 40, 40, 444, 40, 442, 452,
688 449, 40, 445, 40, 40, 40, 451, 40, 448, 40,
689 455, 40, 458, 40, 450, 40, 40, 40, 453, 40,
690 454, 457, 460, 40, 456, 40, 467, 464, 465, 462,
691
692 40, 461, 40, 463, 40, 459, 40, 471, 40, 466,
693 472, 468, 40, 469, 40, 470, 40, 40, 40, 473,
694 40, 474, 40, 40, 40, 475, 477, 40, 478, 479,
695 40, 476, 480, 40, 40, 483, 40, 481, 40, 40,
696 40, 485, 40, 484, 40, 482, 40, 40, 40, 40,
697 40, 492, 487, 493, 40, 491, 486, 488, 40, 489,
698 40, 40, 495, 494, 496, 490, 40, 498, 40, 497,
699 502, 503, 499, 504, 40, 40, 40, 500, 40, 40,
700 40, 40, 40, 505, 40, 501, 507, 40, 40, 509,
701 513, 40, 40, 40, 40, 40, 40, 40, 506, 508,
702
703 40, 517, 514, 519, 510, 511, 518, 512, 515, 40,
704 521, 516, 40, 40, 40, 40, 520, 40, 522, 524,
705 523, 40, 527, 526, 40, 40, 40, 40, 525, 40,
706 528, 530, 40, 40, 40, 40, 533, 40, 40, 40,
707 537, 531, 40, 539, 40, 40, 535, 529, 40, 536,
708 40, 40, 538, 540, 40, 534, 532, 544, 541, 545,
709 40, 40, 40, 542, 40, 40, 40, 40, 543, 548,
710 40, 40, 40, 40, 546, 552, 549, 550, 40, 551,
711 554, 557, 40, 547, 40, 40, 560, 555, 553, 556,
712 40, 559, 40, 558, 40, 40, 40, 40, 40, 561,
713
714 40, 40, 566, 567, 568, 40, 562, 40, 563, 40,
715 40, 40, 572, 40, 40, 564, 565, 40, 571, 573,
716 40, 40, 40, 570, 40, 40, 40, 569, 574, 37,
717 37, 37, 37, 39, 39, 50, 40, 50, 50, 40,
683718 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
684719 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
685720 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
686721 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
722 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
723 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
687724
688725 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
689726 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
690727 40, 40, 40, 40, 40, 40, 40, 40, 40, 40,
691 40, 216, 40, 40, 40, 40, 119, 40, 38, 525,
692 3, 525, 525, 525, 525, 525, 525, 525, 525, 525,
693 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
694 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
695 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
696 525, 525, 525, 525
728 40, 229, 40, 40, 40, 40, 122, 40, 38, 575,
729 3, 575, 575, 575, 575, 575, 575, 575, 575, 575,
730 575, 575, 575, 575, 575, 575, 575, 575, 575, 575,
731 575, 575, 575, 575, 575, 575, 575, 575, 575, 575,
732 575, 575, 575, 575, 575, 575, 575, 575, 575, 575,
733 575, 575, 575, 575
697734 } ;
698735
699 static yyconst short int yy_chk[1185] =
736 static yyconst short int yy_chk[1285] =
700737 { 0,
701738 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
702739 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
709746 26, 29, 63, 46, 16, 54, 26, 20, 17, 23,
710747 29, 16, 17, 16, 18, 16, 13, 17, 16, 18,
711748
712 17, 18, 19, 63, 54, 23, 23, 19, 66, 24,
749 17, 18, 19, 63, 54, 23, 23, 19, 145, 24,
713750 22, 19, 18, 21, 24, 19, 18, 19, 21, 22,
714751 19, 21, 24, 28, 25, 22, 27, 24, 21, 25,
715 51, 34, 33, 66, 21, 28, 58, 33, 51, 31,
716 34, 28, 25, 52, 31, 27, 36, 27, 25, 30,
717 33, 35, 35, 30, 58, 36, 52, 31, 52, 30,
718 31, 30, 30, 53, 56, 30, 30, 31, 530, 72,
719 35, 53, 57, 55, 30, 56, 30, 30, 68, 30,
720 32, 64, 72, 57, 32, 42, 42, 42, 42, 55,
721 32, 61, 32, 43, 43, 43, 43, 32, 61, 32,
722
723 75, 32, 68, 85, 64, 32, 32, 44, 44, 44,
752 145, 24, 21, 33, 21, 28, 35, 35, 33, 31,
753 580, 28, 25, 34, 31, 27, 28, 27, 25, 30,
754 51, 33, 34, 30, 36, 35, 53, 31, 51, 30,
755 31, 30, 30, 36, 53, 30, 30, 31, 42, 42,
756 42, 42, 56, 119, 30, 119, 30, 30, 52, 30,
757 32, 60, 55, 56, 32, 43, 43, 43, 43, 578,
758 32, 52, 32, 52, 55, 61, 60, 32, 55, 32,
759
760 64, 32, 61, 60, 66, 32, 32, 44, 44, 44,
724761 44, 44, 45, 45, 45, 45, 45, 45, 47, 47,
725 47, 47, 47, 75, 79, 47, 85, 116, 528, 116,
726 79, 47, 48, 48, 48, 48, 48, 48, 49, 49,
727 49, 49, 49, 60, 49, 49, 67, 49, 49, 49,
728 49, 49, 49, 65, 69, 71, 70, 73, 60, 74,
729 65, 67, 69, 70, 76, 60, 77, 78, 74, 81,
730 71, 80, 65, 83, 81, 73, 82, 71, 84, 70,
731 86, 83, 76, 91, 89, 77, 81, 90, 80, 78,
732 78, 82, 78, 84, 80, 86, 87, 89, 92, 91,
733
734 90, 87, 93, 94, 95, 96, 91, 97, 98, 101,
735 99, 95, 100, 105, 524, 97, 94, 98, 100, 95,
736 96, 102, 101, 96, 104, 92, 96, 95, 99, 96,
737 93, 106, 105, 107, 102, 108, 109, 104, 111, 140,
738 113, 112, 102, 110, 113, 113, 107, 111, 104, 117,
739 114, 110, 108, 112, 109, 115, 110, 113, 118, 106,
740 115, 140, 129, 114, 110, 114, 522, 521, 133, 110,
741 117, 121, 121, 121, 121, 122, 122, 122, 122, 118,
742 129, 133, 122, 128, 135, 136, 131, 163, 122, 124,
743 124, 124, 124, 124, 128, 131, 124, 137, 520, 135,
744
745 136, 163, 124, 125, 125, 139, 125, 125, 125, 125,
746 125, 142, 141, 139, 143, 144, 142, 147, 146, 148,
747 137, 141, 151, 147, 149, 150, 152, 146, 153, 143,
748 144, 146, 148, 149, 150, 154, 155, 157, 156, 158,
749 154, 159, 160, 157, 151, 155, 150, 156, 161, 152,
750 159, 160, 155, 153, 158, 162, 164, 165, 166, 167,
751 168, 171, 172, 174, 162, 165, 161, 178, 179, 166,
752 207, 223, 181, 188, 167, 207, 171, 180, 223, 164,
753 174, 181, 172, 184, 168, 177, 177, 177, 177, 188,
754 178, 177, 177, 179, 177, 177, 177, 177, 177, 177,
755
756 180, 182, 187, 186, 184, 189, 191, 192, 193, 194,
757 182, 187, 182, 186, 195, 196, 182, 197, 182, 193,
758 198, 199, 192, 195, 196, 200, 189, 201, 194, 191,
759 202, 206, 203, 204, 205, 208, 201, 215, 235, 209,
760 197, 203, 200, 210, 199, 198, 204, 202, 209, 206,
761 205, 210, 211, 212, 213, 215, 208, 211, 213, 217,
762 217, 217, 217, 233, 238, 235, 217, 212, 233, 238,
763 218, 218, 217, 218, 218, 218, 218, 219, 219, 219,
764 219, 220, 220, 220, 220, 220, 221, 221, 221, 221,
765 221, 222, 224, 225, 229, 230, 231, 232, 234, 236,
766
767 240, 229, 237, 239, 242, 245, 251, 243, 222, 224,
768 225, 234, 232, 242, 243, 236, 248, 237, 230, 231,
769 241, 240, 239, 250, 249, 241, 252, 251, 245, 249,
770 253, 248, 250, 254, 255, 256, 259, 262, 260, 263,
771 265, 273, 267, 269, 253, 518, 516, 252, 254, 265,
772 256, 268, 255, 260, 259, 267, 270, 271, 268, 272,
773 274, 262, 263, 269, 273, 270, 271, 275, 272, 277,
774 274, 281, 287, 280, 278, 284, 275, 288, 277, 270,
775 271, 278, 280, 287, 284, 289, 281, 288, 290, 291,
776 293, 294, 295, 290, 296, 298, 301, 300, 289, 302,
777
778 302, 302, 302, 295, 311, 304, 291, 300, 305, 301,
779 304, 293, 294, 307, 313, 314, 305, 308, 298, 300,
780 307, 296, 308, 309, 310, 311, 312, 315, 316, 310,
781 309, 317, 312, 313, 314, 318, 315, 319, 323, 321,
782 324, 325, 326, 327, 319, 316, 321, 323, 337, 328,
783 330, 338, 318, 331, 317, 324, 332, 325, 328, 333,
784 327, 334, 331, 332, 335, 326, 337, 330, 333, 346,
785 334, 347, 350, 335, 338, 349, 351, 355, 358, 356,
786 357, 347, 359, 361, 346, 351, 356, 349, 357, 362,
787 364, 363, 365, 359, 367, 350, 363, 369, 370, 371,
788
789 355, 358, 362, 372, 373, 370, 361, 367, 380, 365,
790 374, 375, 372, 364, 369, 379, 382, 386, 388, 379,
791 379, 384, 386, 393, 385, 388, 373, 371, 374, 375,
792 384, 380, 382, 385, 394, 401, 396, 397, 402, 407,
793 408, 409, 410, 411, 393, 396, 412, 397, 401, 409,
794 402, 394, 414, 417, 407, 410, 418, 419, 420, 421,
795 411, 423, 408, 422, 424, 425, 426, 427, 421, 412,
796 414, 429, 422, 420, 417, 426, 430, 418, 423, 424,
797 425, 431, 432, 419, 433, 430, 431, 432, 434, 427,
798 435, 436, 437, 433, 439, 442, 429, 435, 440, 441,
799
800 444, 446, 445, 437, 442, 452, 515, 447, 451, 514,
801 450, 434, 452, 453, 436, 444, 447, 451, 439, 445,
802 454, 440, 441, 450, 446, 456, 454, 458, 453, 457,
803 460, 463, 456, 464, 457, 465, 463, 468, 466, 467,
804 458, 469, 464, 466, 470, 472, 471, 473, 469, 474,
805 479, 475, 473, 460, 477, 467, 475, 478, 465, 471,
806 472, 480, 481, 482, 474, 483, 468, 470, 477, 479,
807 485, 481, 482, 478, 486, 487, 488, 489, 491, 492,
808 493, 494, 496, 486, 480, 497, 499, 491, 483, 500,
809 487, 488, 489, 493, 497, 501, 500, 502, 494, 485,
810
811 496, 499, 492, 503, 504, 505, 506, 507, 501, 508,
812 509, 510, 511, 513, 502, 507, 508, 509, 517, 512,
813 519, 523, 504, 498, 503, 517, 495, 506, 505, 519,
814 513, 490, 484, 476, 462, 511, 461, 459, 455, 449,
815 510, 448, 523, 526, 526, 526, 526, 527, 527, 529,
816 443, 529, 529, 438, 428, 416, 415, 413, 406, 405,
817 404, 403, 400, 399, 398, 395, 392, 391, 390, 389,
818 387, 383, 381, 378, 377, 376, 368, 366, 360, 354,
819 353, 352, 348, 345, 344, 343, 342, 341, 340, 339,
820 336, 329, 322, 320, 306, 303, 299, 297, 292, 286,
821
822 285, 283, 282, 279, 276, 266, 261, 258, 257, 247,
823 246, 244, 228, 227, 226, 214, 190, 185, 183, 176,
824 175, 173, 170, 169, 145, 138, 134, 132, 130, 127,
825 123, 119, 103, 88, 59, 39, 37, 8, 7, 3,
826 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
827 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
828 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
829 525, 525, 525, 525, 525, 525, 525, 525, 525, 525,
830 525, 525, 525, 525
762 47, 47, 47, 64, 80, 47, 574, 572, 58, 66,
763 80, 47, 48, 48, 48, 48, 48, 48, 49, 49,
764 49, 49, 49, 57, 49, 49, 58, 49, 49, 49,
765 49, 49, 49, 65, 57, 67, 68, 69, 72, 71,
766 65, 70, 76, 199, 73, 69, 57, 74, 70, 75,
767 67, 72, 65, 77, 71, 78, 74, 79, 75, 199,
768 68, 71, 73, 83, 70, 76, 81, 82, 85, 96,
769 74, 77, 82, 84, 78, 83, 85, 86, 87, 79,
770
771 79, 88, 79, 81, 82, 89, 91, 92, 84, 81,
772 89, 93, 86, 94, 95, 97, 88, 96, 101, 91,
773 92, 87, 102, 98, 99, 103, 100, 101, 97, 94,
774 98, 103, 93, 108, 100, 109, 94, 112, 98, 99,
775 102, 95, 99, 104, 105, 99, 98, 107, 99, 100,
776 98, 110, 108, 111, 113, 112, 104, 105, 571, 114,
777 107, 115, 113, 109, 110, 105, 120, 113, 114, 117,
778 111, 107, 118, 115, 116, 113, 111, 118, 116, 116,
779 113, 121, 117, 132, 117, 147, 135, 120, 217, 131,
780 147, 116, 124, 124, 124, 124, 125, 125, 125, 125,
781
782 131, 132, 121, 125, 217, 137, 134, 135, 121, 125,
783 127, 127, 127, 127, 127, 134, 142, 127, 137, 139,
784 140, 141, 148, 127, 128, 128, 139, 128, 128, 128,
785 128, 128, 144, 146, 149, 140, 141, 148, 151, 142,
786 144, 153, 146, 154, 152, 157, 155, 151, 156, 149,
787 152, 151, 154, 158, 153, 155, 159, 160, 161, 164,
788 163, 159, 165, 166, 162, 164, 167, 155, 157, 163,
789 156, 170, 166, 162, 168, 167, 161, 165, 158, 161,
790 162, 169, 171, 172, 160, 170, 173, 174, 175, 167,
791 169, 172, 168, 176, 179, 180, 182, 173, 183, 194,
792
793 196, 188, 190, 175, 187, 171, 222, 189, 174, 179,
794 196, 190, 339, 182, 222, 180, 192, 176, 339, 202,
795 194, 183, 186, 186, 186, 186, 188, 187, 186, 186,
796 189, 186, 186, 186, 186, 186, 186, 191, 197, 192,
797 198, 200, 202, 208, 203, 204, 191, 197, 191, 205,
798 209, 207, 191, 210, 191, 206, 204, 212, 198, 203,
799 207, 211, 200, 214, 206, 228, 208, 218, 205, 213,
800 216, 220, 206, 215, 212, 209, 210, 224, 213, 211,
801 214, 219, 215, 216, 221, 218, 219, 227, 228, 223,
802 236, 224, 220, 221, 223, 225, 272, 236, 296, 225,
803
804 230, 230, 230, 230, 240, 227, 570, 230, 296, 240,
805 272, 231, 231, 230, 231, 231, 231, 231, 232, 232,
806 232, 232, 233, 233, 233, 233, 233, 234, 234, 234,
807 234, 234, 235, 237, 239, 244, 245, 246, 247, 248,
808 250, 249, 244, 252, 248, 251, 254, 253, 255, 235,
809 237, 239, 253, 247, 249, 257, 258, 256, 252, 245,
810 246, 251, 256, 258, 257, 254, 260, 250, 261, 255,
811 262, 263, 266, 267, 268, 269, 270, 568, 267, 283,
812 271, 566, 274, 268, 273, 279, 275, 266, 282, 260,
813 280, 261, 262, 284, 262, 263, 269, 270, 271, 273,
814
815 274, 275, 283, 279, 286, 280, 288, 289, 290, 291,
816 295, 284, 282, 286, 289, 292, 293, 297, 291, 288,
817 298, 304, 300, 565, 292, 293, 297, 301, 290, 314,
818 298, 300, 291, 295, 301, 303, 304, 311, 292, 306,
819 308, 312, 314, 313, 303, 315, 306, 311, 316, 308,
820 315, 318, 312, 313, 319, 320, 321, 323, 326, 325,
821 328, 328, 328, 328, 333, 316, 320, 334, 330, 325,
822 331, 326, 318, 330, 334, 319, 338, 335, 331, 340,
823 323, 325, 335, 321, 336, 337, 333, 341, 343, 344,
824 337, 336, 342, 345, 351, 346, 348, 338, 340, 353,
825
826 352, 342, 346, 348, 355, 343, 341, 351, 354, 356,
827 345, 357, 344, 352, 358, 360, 353, 354, 359, 355,
828 363, 362, 370, 364, 360, 356, 365, 366, 371, 363,
829 364, 358, 367, 368, 357, 365, 366, 359, 362, 379,
830 370, 367, 380, 381, 383, 384, 368, 388, 385, 391,
831 393, 371, 380, 392, 379, 394, 383, 385, 393, 395,
832 392, 397, 381, 398, 399, 400, 388, 403, 384, 399,
833 395, 404, 391, 401, 406, 407, 398, 408, 394, 410,
834 403, 411, 407, 409, 397, 412, 417, 427, 400, 421,
835 401, 406, 409, 416, 404, 422, 421, 416, 416, 411,
836
837 434, 410, 426, 412, 424, 408, 425, 426, 435, 417,
838 427, 422, 429, 424, 436, 425, 445, 438, 439, 429,
839 446, 434, 451, 452, 455, 435, 438, 453, 439, 445,
840 454, 436, 446, 457, 459, 453, 462, 451, 463, 464,
841 465, 455, 466, 454, 468, 452, 469, 470, 472, 471,
842 474, 466, 459, 468, 475, 465, 457, 462, 473, 463,
843 477, 478, 470, 469, 471, 464, 479, 473, 480, 472,
844 478, 479, 474, 480, 481, 482, 484, 475, 485, 483,
845 487, 490, 488, 481, 489, 477, 483, 492, 494, 485,
846 490, 493, 495, 499, 501, 503, 564, 562, 482, 484,
847
848 510, 495, 492, 501, 487, 488, 499, 489, 493, 502,
849 503, 494, 504, 506, 507, 508, 502, 513, 504, 507,
850 506, 514, 513, 510, 515, 517, 516, 518, 508, 519,
851 514, 516, 520, 521, 522, 523, 519, 524, 525, 527,
852 523, 517, 528, 525, 529, 530, 521, 515, 531, 522,
853 532, 533, 524, 527, 535, 520, 518, 531, 528, 532,
854 536, 537, 538, 529, 539, 542, 541, 543, 530, 536,
855 544, 546, 547, 551, 533, 541, 537, 538, 549, 539,
856 543, 547, 552, 535, 550, 553, 551, 544, 542, 546,
857 554, 550, 555, 549, 557, 556, 558, 559, 560, 552,
858
859 561, 563, 557, 558, 559, 567, 553, 573, 554, 548,
860 569, 545, 567, 540, 534, 555, 556, 526, 563, 569,
861 512, 511, 509, 561, 505, 500, 498, 560, 573, 576,
862 576, 576, 576, 577, 577, 579, 497, 579, 579, 496,
863 491, 486, 476, 467, 461, 460, 458, 456, 450, 449,
864 448, 447, 444, 443, 442, 441, 440, 437, 433, 432,
865 431, 430, 428, 423, 420, 419, 418, 415, 414, 413,
866 405, 402, 396, 390, 389, 387, 386, 382, 378, 377,
867 376, 375, 374, 373, 372, 369, 361, 350, 349, 347,
868 332, 329, 327, 324, 322, 317, 310, 309, 307, 305,
869
870 302, 299, 294, 287, 281, 278, 277, 276, 265, 264,
871 259, 243, 242, 241, 238, 226, 201, 195, 193, 185,
872 184, 181, 178, 177, 150, 143, 138, 136, 133, 130,
873 126, 122, 106, 90, 59, 39, 37, 8, 7, 3,
874 575, 575, 575, 575, 575, 575, 575, 575, 575, 575,
875 575, 575, 575, 575, 575, 575, 575, 575, 575, 575,
876 575, 575, 575, 575, 575, 575, 575, 575, 575, 575,
877 575, 575, 575, 575, 575, 575, 575, 575, 575, 575,
878 575, 575, 575, 575
831879 } ;
832880
833881 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
844892 #define YY_MORE_ADJ 0
845893 #define YY_RESTORE_YY_MORE_OFFSET
846894 char *yytext;
847 #line 1 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
895 #line 1 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
848896 #define INITIAL 0
849897 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
850898 //
859907 //
860908 //===----------------------------------------------------------------------===*/
861909 #define YY_NEVER_INTERACTIVE 1
862 #line 28 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
910 #line 28 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
863911 #include "ParserInternals.h"
864912 #include "llvm/Module.h"
865913 #include
886934 llvmAsmlval.type.obsolete = true; \
887935 return sym
888936
937 // Construct a token value for a non-obsolete type
938 #define RET_TY(CType, sym) \
939 llvmAsmlval.TypeVal.type = new PATypeHolder(CType); \
940 llvmAsmlval.TypeVal.signedness = isSignless; \
941 return sym
942
943 // Construct a token value for an obsolete token
944 #define RET_TY_OBSOLETE(CType, sign, sym) \
945 llvmAsmlval.TypeVal.type = new PATypeHolder(CType); \
946 llvmAsmlval.TypeVal.signedness = sign; \
947 return sym
889948
890949 namespace llvm {
891950
9951054 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
9961055 * it to deal with 64 bit numbers.
9971056 */
998 #line 1000 "Lexer.cpp"
1057 #line 1059 "Lexer.cpp"
9991058
10001059 /* Macros after this point can all be overridden by user definitions in
10011060 * section 1.
11431202 YY_DECL
11441203 {
11451204 register yy_state_type yy_current_state;
1146 register char *yy_cp, *yy_bp;
1205 register char *yy_cp = NULL, *yy_bp = NULL;
11471206 register int yy_act;
11481207
1149 #line 189 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1150
1151
1152 #line 1154 "Lexer.cpp"
1208 #line 200 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1209
1210
1211 #line 1213 "Lexer.cpp"
11531212
11541213 if ( yy_init )
11551214 {
11971256 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
11981257 {
11991258 yy_current_state = (int) yy_def[yy_current_state];
1200 if ( yy_current_state >= 526 )
1259 if ( yy_current_state >= 576 )
12011260 yy_c = yy_meta[(unsigned int) yy_c];
12021261 }
12031262 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
12041263 *yy_state_ptr++ = yy_current_state;
12051264 ++yy_cp;
12061265 }
1207 while ( yy_current_state != 525 );
1266 while ( yy_current_state != 575 );
12081267
12091268 yy_find_action:
12101269 yy_current_state = *--yy_state_ptr;
12421301 { /* beginning of action switch */
12431302 case 1:
12441303 YY_RULE_SETUP
1245 #line 191 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1304 #line 202 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12461305 { /* Ignore comments for now */ }
12471306 YY_BREAK
12481307 case 2:
12491308 YY_RULE_SETUP
1250 #line 193 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1309 #line 204 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12511310 { return BEGINTOK; }
12521311 YY_BREAK
12531312 case 3:
12541313 YY_RULE_SETUP
1255 #line 194 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1314 #line 205 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12561315 { return ENDTOK; }
12571316 YY_BREAK
12581317 case 4:
12591318 YY_RULE_SETUP
1260 #line 195 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1319 #line 206 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12611320 { return TRUETOK; }
12621321 YY_BREAK
12631322 case 5:
12641323 YY_RULE_SETUP
1265 #line 196 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1324 #line 207 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12661325 { return FALSETOK; }
12671326 YY_BREAK
12681327 case 6:
12691328 YY_RULE_SETUP
1270 #line 197 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1329 #line 208 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12711330 { return DECLARE; }
12721331 YY_BREAK
12731332 case 7:
12741333 YY_RULE_SETUP
1275 #line 198 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1334 #line 209 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12761335 { return GLOBAL; }
12771336 YY_BREAK
12781337 case 8:
12791338 YY_RULE_SETUP
1280 #line 199 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1339 #line 210 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12811340 { return CONSTANT; }
12821341 YY_BREAK
12831342 case 9:
12841343 YY_RULE_SETUP
1285 #line 200 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1344 #line 211 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12861345 { return INTERNAL; }
12871346 YY_BREAK
12881347 case 10:
12891348 YY_RULE_SETUP
1290 #line 201 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1349 #line 212 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12911350 { return LINKONCE; }
12921351 YY_BREAK
12931352 case 11:
12941353 YY_RULE_SETUP
1295 #line 202 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1354 #line 213 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
12961355 { return WEAK; }
12971356 YY_BREAK
12981357 case 12:
12991358 YY_RULE_SETUP
1300 #line 203 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1359 #line 214 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13011360 { return APPENDING; }
13021361 YY_BREAK
13031362 case 13:
13041363 YY_RULE_SETUP
1305 #line 204 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1364 #line 215 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13061365 { return DLLIMPORT; }
13071366 YY_BREAK
13081367 case 14:
13091368 YY_RULE_SETUP
1310 #line 205 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1369 #line 216 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13111370 { return DLLEXPORT; }
13121371 YY_BREAK
13131372 case 15:
13141373 YY_RULE_SETUP
1315 #line 206 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1374 #line 217 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13161375 { return EXTERN_WEAK; }
13171376 YY_BREAK
13181377 case 16:
13191378 YY_RULE_SETUP
1320 #line 207 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1379 #line 218 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13211380 { return EXTERNAL; } /* Deprecated, turn into external */
13221381 YY_BREAK
13231382 case 17:
13241383 YY_RULE_SETUP
1325 #line 208 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1384 #line 219 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13261385 { return EXTERNAL; }
13271386 YY_BREAK
13281387 case 18:
13291388 YY_RULE_SETUP
1330 #line 209 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1389 #line 220 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13311390 { return IMPLEMENTATION; }
13321391 YY_BREAK
13331392 case 19:
13341393 YY_RULE_SETUP
1335 #line 210 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1394 #line 221 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13361395 { return ZEROINITIALIZER; }
13371396 YY_BREAK
13381397 case 20:
13391398 YY_RULE_SETUP
1340 #line 211 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1399 #line 222 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13411400 { return DOTDOTDOT; }
13421401 YY_BREAK
13431402 case 21:
13441403 YY_RULE_SETUP
1345 #line 212 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1404 #line 223 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13461405 { return UNDEF; }
13471406 YY_BREAK
13481407 case 22:
13491408 YY_RULE_SETUP
1350 #line 213 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1409 #line 224 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13511410 { return NULL_TOK; }
13521411 YY_BREAK
13531412 case 23:
13541413 YY_RULE_SETUP
1355 #line 214 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1414 #line 225 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13561415 { return TO; }
13571416 YY_BREAK
13581417 case 24:
13591418 YY_RULE_SETUP
1360 #line 215 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1419 #line 226 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13611420 { RET_TOK(TermOpVal, Unwind, UNWIND); }
13621421 YY_BREAK
13631422 case 25:
13641423 YY_RULE_SETUP
1365 #line 216 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1424 #line 227 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13661425 { return NOT; } /* Deprecated, turned into XOR */
13671426 YY_BREAK
13681427 case 26:
13691428 YY_RULE_SETUP
1370 #line 217 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1429 #line 228 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13711430 { return TAIL; }
13721431 YY_BREAK
13731432 case 27:
13741433 YY_RULE_SETUP
1375 #line 218 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1434 #line 229 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13761435 { return TARGET; }
13771436 YY_BREAK
13781437 case 28:
13791438 YY_RULE_SETUP
1380 #line 219 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1439 #line 230 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13811440 { return TRIPLE; }
13821441 YY_BREAK
13831442 case 29:
13841443 YY_RULE_SETUP
1385 #line 220 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1444 #line 231 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13861445 { return DEPLIBS; }
13871446 YY_BREAK
13881447 case 30:
13891448 YY_RULE_SETUP
1390 #line 221 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1449 #line 232 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13911450 { return ENDIAN; }
13921451 YY_BREAK
13931452 case 31:
13941453 YY_RULE_SETUP
1395 #line 222 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1454 #line 233 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
13961455 { return POINTERSIZE; }
13971456 YY_BREAK
13981457 case 32:
13991458 YY_RULE_SETUP
1400 #line 223 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1459 #line 234 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14011460 { return DATALAYOUT; }
14021461 YY_BREAK
14031462 case 33:
14041463 YY_RULE_SETUP
1405 #line 224 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1464 #line 235 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14061465 { return LITTLE; }
14071466 YY_BREAK
14081467 case 34:
14091468 YY_RULE_SETUP
1410 #line 225 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1469 #line 236 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14111470 { return BIG; }
14121471 YY_BREAK
14131472 case 35:
14141473 YY_RULE_SETUP
1415 #line 226 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1474 #line 237 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14161475 { return VOLATILE; }
14171476 YY_BREAK
14181477 case 36:
14191478 YY_RULE_SETUP
1420 #line 227 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1479 #line 238 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14211480 { return ALIGN; }
14221481 YY_BREAK
14231482 case 37:
14241483 YY_RULE_SETUP
1425 #line 228 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1484 #line 239 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14261485 { return SECTION; }
14271486 YY_BREAK
14281487 case 38:
14291488 YY_RULE_SETUP
1430 #line 229 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1489 #line 240 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14311490 { return MODULE; }
14321491 YY_BREAK
14331492 case 39:
14341493 YY_RULE_SETUP
1435 #line 230 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1494 #line 241 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14361495 { return ASM_TOK; }
14371496 YY_BREAK
14381497 case 40:
14391498 YY_RULE_SETUP
1440 #line 231 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1499 #line 242 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14411500 { return SIDEEFFECT; }
14421501 YY_BREAK
14431502 case 41:
14441503 YY_RULE_SETUP
1445 #line 233 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1504 #line 244 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14461505 { return CC_TOK; }
14471506 YY_BREAK
14481507 case 42:
14491508 YY_RULE_SETUP
1450 #line 234 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1509 #line 245 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14511510 { return CCC_TOK; }
14521511 YY_BREAK
14531512 case 43:
14541513 YY_RULE_SETUP
1455 #line 235 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1514 #line 246 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14561515 { return CSRETCC_TOK; }
14571516 YY_BREAK
14581517 case 44:
14591518 YY_RULE_SETUP
1460 #line 236 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1519 #line 247 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14611520 { return FASTCC_TOK; }
14621521 YY_BREAK
14631522 case 45:
14641523 YY_RULE_SETUP
1465 #line 237 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1524 #line 248 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14661525 { return COLDCC_TOK; }
14671526 YY_BREAK
14681527 case 46:
14691528 YY_RULE_SETUP
1470 #line 238 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1529 #line 249 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14711530 { return X86_STDCALLCC_TOK; }
14721531 YY_BREAK
14731532 case 47:
14741533 YY_RULE_SETUP
1475 #line 239 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1534 #line 250 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
14761535 { return X86_FASTCALLCC_TOK; }
14771536 YY_BREAK
14781537 case 48:
14791538 YY_RULE_SETUP
1480 #line 241 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1481 { llvmAsmlval.PrimType = Type::VoidTy ; return VOID; }
1539 #line 252 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1540 { RET_TY(Type::VoidTy, VOID); }
14821541 YY_BREAK
14831542 case 49:
14841543 YY_RULE_SETUP
1485 #line 242 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1486 { llvmAsmlval.PrimType = Type::BoolTy ; return BOOL; }
1544 #line 253 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1545 { RET_TY(Type::BoolTy, BOOL); }
14871546 YY_BREAK
14881547 case 50:
14891548 YY_RULE_SETUP
1490 #line 243 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1491 { llvmAsmlval.PrimType = Type::SByteTy ; return SBYTE; }
1549 #line 254 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1550 { RET_TY_OBSOLETE(Type::SByteTy, isSigned, SBYTE); }
14921551 YY_BREAK
14931552 case 51:
14941553 YY_RULE_SETUP
1495 #line 244 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1496 { llvmAsmlval.PrimType = Type::UByteTy ; return UBYTE; }
1554 #line 255 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1555 { RET_TY_OBSOLETE(Type::UByteTy, isUnsigned, UBYTE); }
14971556 YY_BREAK
14981557 case 52:
14991558 YY_RULE_SETUP
1500 #line 245 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1501 { llvmAsmlval.PrimType = Type::ShortTy ; return SHORT; }
1559 #line 256 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1560 { RET_TY_OBSOLETE(Type::ShortTy, isSigned, SHORT); }
15021561 YY_BREAK
15031562 case 53:
15041563 YY_RULE_SETUP
1505 #line 246 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1506 { llvmAsmlval.PrimType = Type::UShortTy; return USHORT; }
1564 #line 257 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1565 { RET_TY_OBSOLETE(Type::UShortTy,isUnsigned, USHORT); }
15071566 YY_BREAK
15081567 case 54:
15091568 YY_RULE_SETUP
1510 #line 247 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1511 { llvmAsmlval.PrimType = Type::IntTy ; return INT; }
1569 #line 258 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1570 { RET_TY_OBSOLETE(Type::IntTy, isSigned, INT); }
15121571 YY_BREAK
15131572 case 55:
15141573 YY_RULE_SETUP
1515 #line 248 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1516 { llvmAsmlval.PrimType = Type::UIntTy ; return UINT; }
1574 #line 259 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1575 { RET_TY_OBSOLETE(Type::UIntTy, isUnsigned, UINT); }
15171576 YY_BREAK
15181577 case 56:
15191578 YY_RULE_SETUP
1520 #line 249 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1521 { llvmAsmlval.PrimType = Type::LongTy ; return LONG; }
1579 #line 260 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1580 { RET_TY_OBSOLETE(Type::LongTy, isSigned, LONG); }
15221581 YY_BREAK
15231582 case 57:
15241583 YY_RULE_SETUP
1525 #line 250 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1526 { llvmAsmlval.PrimType = Type::ULongTy ; return ULONG; }
1584 #line 261 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1585 { RET_TY_OBSOLETE(Type::ULongTy, isUnsigned, ULONG); }
15271586 YY_BREAK
15281587 case 58:
15291588 YY_RULE_SETUP
1530 #line 251 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1531 { llvmAsmlval.PrimType = Type::FloatTy ; return FLOAT; }
1589 #line 262 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1590 { RET_TY(Type::FloatTy, FLOAT); }
15321591 YY_BREAK
15331592 case 59:
15341593 YY_RULE_SETUP
1535 #line 252 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1536 { llvmAsmlval.PrimType = Type::DoubleTy; return DOUBLE; }
1594 #line 263 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1595 { RET_TY(Type::DoubleTy, DOUBLE); }
15371596 YY_BREAK
15381597 case 60:
15391598 YY_RULE_SETUP
1540 #line 253 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1541 { llvmAsmlval.PrimType = Type::LabelTy ; return LABEL; }
1599 #line 264 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1600 { RET_TY(Type::LabelTy, LABEL); }
15421601 YY_BREAK
15431602 case 61:
15441603 YY_RULE_SETUP
1545 #line 254 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1604 #line 265 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15461605 { return TYPE; }
15471606 YY_BREAK
15481607 case 62:
15491608 YY_RULE_SETUP
1550 #line 255 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1609 #line 266 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15511610 { return OPAQUE; }
15521611 YY_BREAK
15531612 case 63:
15541613 YY_RULE_SETUP
1555 #line 257 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1614 #line 268 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15561615 { RET_TOK(BinaryOpVal, Add, ADD); }
15571616 YY_BREAK
15581617 case 64:
15591618 YY_RULE_SETUP
1560 #line 258 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1619 #line 269 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15611620 { RET_TOK(BinaryOpVal, Sub, SUB); }
15621621 YY_BREAK
15631622 case 65:
15641623 YY_RULE_SETUP
1565 #line 259 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1624 #line 270 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15661625 { RET_TOK(BinaryOpVal, Mul, MUL); }
15671626 YY_BREAK
15681627 case 66:
15691628 YY_RULE_SETUP
1570 #line 260 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1629 #line 271 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15711630 { RET_TOK_OBSOLETE(BinaryOpVal, UDiv, UDIV); }
15721631 YY_BREAK
15731632 case 67:
15741633 YY_RULE_SETUP
1575 #line 261 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1634 #line 272 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15761635 { RET_TOK(BinaryOpVal, UDiv, UDIV); }
15771636 YY_BREAK
15781637 case 68:
15791638 YY_RULE_SETUP
1580 #line 262 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1639 #line 273 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15811640 { RET_TOK(BinaryOpVal, SDiv, SDIV); }
15821641 YY_BREAK
15831642 case 69:
15841643 YY_RULE_SETUP
1585 #line 263 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1644 #line 274 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15861645 { RET_TOK(BinaryOpVal, FDiv, FDIV); }
15871646 YY_BREAK
15881647 case 70:
15891648 YY_RULE_SETUP
1590 #line 264 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1649 #line 275 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15911650 { RET_TOK_OBSOLETE(BinaryOpVal, URem, UREM); }
15921651 YY_BREAK
15931652 case 71:
15941653 YY_RULE_SETUP
1595 #line 265 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1654 #line 276 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
15961655 { RET_TOK(BinaryOpVal, URem, UREM); }
15971656 YY_BREAK
15981657 case 72:
15991658 YY_RULE_SETUP
1600 #line 266 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1659 #line 277 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16011660 { RET_TOK(BinaryOpVal, SRem, SREM); }
16021661 YY_BREAK
16031662 case 73:
16041663 YY_RULE_SETUP
1605 #line 267 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1664 #line 278 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16061665 { RET_TOK(BinaryOpVal, FRem, FREM); }
16071666 YY_BREAK
16081667 case 74:
16091668 YY_RULE_SETUP
1610 #line 268 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1669 #line 279 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16111670 { RET_TOK(BinaryOpVal, And, AND); }
16121671 YY_BREAK
16131672 case 75:
16141673 YY_RULE_SETUP
1615 #line 269 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1674 #line 280 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16161675 { RET_TOK(BinaryOpVal, Or , OR ); }
16171676 YY_BREAK
16181677 case 76:
16191678 YY_RULE_SETUP
1620 #line 270 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1679 #line 281 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16211680 { RET_TOK(BinaryOpVal, Xor, XOR); }
16221681 YY_BREAK
16231682 case 77:
16241683 YY_RULE_SETUP
1625 #line 271 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1684 #line 282 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16261685 { RET_TOK(BinaryOpVal, SetNE, SETNE); }
16271686 YY_BREAK
16281687 case 78:
16291688 YY_RULE_SETUP
1630 #line 272 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1689 #line 283 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16311690 { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
16321691 YY_BREAK
16331692 case 79:
16341693 YY_RULE_SETUP
1635 #line 273 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1694 #line 284 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16361695 { RET_TOK(BinaryOpVal, SetLT, SETLT); }
16371696 YY_BREAK
16381697 case 80:
16391698 YY_RULE_SETUP
1640 #line 274 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1699 #line 285 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16411700 { RET_TOK(BinaryOpVal, SetGT, SETGT); }
16421701 YY_BREAK
16431702 case 81:
16441703 YY_RULE_SETUP
1645 #line 275 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1704 #line 286 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16461705 { RET_TOK(BinaryOpVal, SetLE, SETLE); }
16471706 YY_BREAK
16481707 case 82:
16491708 YY_RULE_SETUP
1650 #line 276 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1709 #line 287 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16511710 { RET_TOK(BinaryOpVal, SetGE, SETGE); }
16521711 YY_BREAK
16531712 case 83:
16541713 YY_RULE_SETUP
1655 #line 278 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1714 #line 289 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16561715 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
16571716 YY_BREAK
16581717 case 84:
16591718 YY_RULE_SETUP
1660 #line 279 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1719 #line 290 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16611720 { RET_TOK(OtherOpVal, Call, CALL); }
16621721 YY_BREAK
16631722 case 85:
16641723 YY_RULE_SETUP
1665 #line 280 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1666 { RET_TOK(OtherOpVal, Cast, CAST); }
1724 #line 291 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1725 { RET_TOK_OBSOLETE(CastOpVal, Trunc, TRUNC); }
16671726 YY_BREAK
16681727 case 86:
16691728 YY_RULE_SETUP
1670 #line 281 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1729 #line 292 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1730 { RET_TOK(CastOpVal, Trunc, TRUNC); }
1731 YY_BREAK
1732 case 87:
1733 YY_RULE_SETUP
1734 #line 293 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1735 { RET_TOK(CastOpVal, ZExt, ZEXT); }
1736 YY_BREAK
1737 case 88:
1738 YY_RULE_SETUP
1739 #line 294 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1740 { RET_TOK(CastOpVal, SExt, SEXT); }
1741 YY_BREAK
1742 case 89:
1743 YY_RULE_SETUP
1744 #line 295 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1745 { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
1746 YY_BREAK
1747 case 90:
1748 YY_RULE_SETUP
1749 #line 296 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1750 { RET_TOK(CastOpVal, FPExt, FPEXT); }
1751 YY_BREAK
1752 case 91:
1753 YY_RULE_SETUP
1754 #line 297 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1755 { RET_TOK(CastOpVal, UIToFP, UITOFP); }
1756 YY_BREAK
1757 case 92:
1758 YY_RULE_SETUP
1759 #line 298 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1760 { RET_TOK(CastOpVal, SIToFP, SITOFP); }
1761 YY_BREAK
1762 case 93:
1763 YY_RULE_SETUP
1764 #line 299 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1765 { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
1766 YY_BREAK
1767 case 94:
1768 YY_RULE_SETUP
1769 #line 300 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1770 { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
1771 YY_BREAK
1772 case 95:
1773 YY_RULE_SETUP
1774 #line 301 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1775 { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
1776 YY_BREAK
1777 case 96:
1778 YY_RULE_SETUP
1779 #line 302 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1780 { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
1781 YY_BREAK
1782 case 97:
1783 YY_RULE_SETUP
1784 #line 303 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1785 { RET_TOK(CastOpVal, BitCast, BITCAST); }
1786 YY_BREAK
1787 case 98:
1788 YY_RULE_SETUP
1789 #line 304 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16711790 { RET_TOK(OtherOpVal, Select, SELECT); }
16721791 YY_BREAK
1673 case 87:
1674 YY_RULE_SETUP
1675 #line 282 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1792 case 99:
1793 YY_RULE_SETUP
1794 #line 305 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16761795 { RET_TOK(OtherOpVal, Shl, SHL); }
16771796 YY_BREAK
1678 case 88:
1679 YY_RULE_SETUP
1680 #line 283 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1681 { RET_TOK(OtherOpVal, Shr, SHR); }
1682 YY_BREAK
1683 case 89:
1684 YY_RULE_SETUP
1685 #line 284 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1797 case 100:
1798 YY_RULE_SETUP
1799 #line 306 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1800 { RET_TOK_OBSOLETE(OtherOpVal, LShr, LSHR); }
1801 YY_BREAK
1802 case 101:
1803 YY_RULE_SETUP
1804 #line 307 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1805 { RET_TOK(OtherOpVal, LShr, LSHR); }
1806 YY_BREAK
1807 case 102:
1808 YY_RULE_SETUP
1809 #line 308 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
1810 { RET_TOK(OtherOpVal, AShr, ASHR); }
1811 YY_BREAK
1812 case 103:
1813 YY_RULE_SETUP
1814 #line 309 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16861815 { return VANEXT_old; }
16871816 YY_BREAK
1688 case 90:
1689 YY_RULE_SETUP
1690 #line 285 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1817 case 104:
1818 YY_RULE_SETUP
1819 #line 310 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16911820 { return VAARG_old; }
16921821 YY_BREAK
1693 case 91:
1694 YY_RULE_SETUP
1695 #line 286 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1822 case 105:
1823 YY_RULE_SETUP
1824 #line 311 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
16961825 { RET_TOK(OtherOpVal, VAArg , VAARG); }
16971826 YY_BREAK
1698 case 92:
1699 YY_RULE_SETUP
1700 #line 287 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1827 case 106:
1828 YY_RULE_SETUP
1829 #line 312 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17011830 { RET_TOK(TermOpVal, Ret, RET); }
17021831 YY_BREAK
1703 case 93:
1704 YY_RULE_SETUP
1705 #line 288 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1832 case 107:
1833 YY_RULE_SETUP
1834 #line 313 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17061835 { RET_TOK(TermOpVal, Br, BR); }
17071836 YY_BREAK
1708 case 94:
1709 YY_RULE_SETUP
1710 #line 289 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1837 case 108:
1838 YY_RULE_SETUP
1839 #line 314 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17111840 { RET_TOK(TermOpVal, Switch, SWITCH); }
17121841 YY_BREAK
1713 case 95:
1714 YY_RULE_SETUP
1715 #line 290 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1842 case 109:
1843 YY_RULE_SETUP
1844 #line 315 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17161845 { RET_TOK(TermOpVal, Invoke, INVOKE); }
17171846 YY_BREAK
1718 case 96:
1719 YY_RULE_SETUP
1720 #line 291 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1847 case 110:
1848 YY_RULE_SETUP
1849 #line 316 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17211850 { RET_TOK(TermOpVal, Unwind, UNWIND); }
17221851 YY_BREAK
1723 case 97:
1724 YY_RULE_SETUP
1725 #line 292 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1852 case 111:
1853 YY_RULE_SETUP
1854 #line 317 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17261855 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
17271856 YY_BREAK
1728 case 98:
1729 YY_RULE_SETUP
1730 #line 294 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1857 case 112:
1858 YY_RULE_SETUP
1859 #line 319 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17311860 { RET_TOK(MemOpVal, Malloc, MALLOC); }
17321861 YY_BREAK
1733 case 99:
1734 YY_RULE_SETUP
1735 #line 295 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1862 case 113:
1863 YY_RULE_SETUP
1864 #line 320 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17361865 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
17371866 YY_BREAK
1738 case 100:
1739 YY_RULE_SETUP
1740 #line 296 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1867 case 114:
1868 YY_RULE_SETUP
1869 #line 321 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17411870 { RET_TOK(MemOpVal, Free, FREE); }
17421871 YY_BREAK
1743 case 101:
1744 YY_RULE_SETUP
1745 #line 297 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1872 case 115:
1873 YY_RULE_SETUP
1874 #line 322 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17461875 { RET_TOK(MemOpVal, Load, LOAD); }
17471876 YY_BREAK
1748 case 102:
1749 YY_RULE_SETUP
1750 #line 298 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1877 case 116:
1878 YY_RULE_SETUP
1879 #line 323 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17511880 { RET_TOK(MemOpVal, Store, STORE); }
17521881 YY_BREAK
1753 case 103:
1754 YY_RULE_SETUP
1755 #line 299 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1882 case 117:
1883 YY_RULE_SETUP
1884 #line 324 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17561885 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
17571886 YY_BREAK
1758 case 104:
1759 YY_RULE_SETUP
1760 #line 301 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1887 case 118:
1888 YY_RULE_SETUP
1889 #line 326 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17611890 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
17621891 YY_BREAK
1763 case 105:
1764 YY_RULE_SETUP
1765 #line 302 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1892 case 119:
1893 YY_RULE_SETUP
1894 #line 327 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17661895 { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
17671896 YY_BREAK
1768 case 106:
1769 YY_RULE_SETUP
1770 #line 303 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1897 case 120:
1898 YY_RULE_SETUP
1899 #line 328 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17711900 { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
17721901 YY_BREAK
1773 case 107:
1774 YY_RULE_SETUP
1775 #line 306 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1902 case 121:
1903 YY_RULE_SETUP
1904 #line 331 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17761905 {
17771906 UnEscapeLexed(yytext+1);
17781907 llvmAsmlval.StrVal = strdup(yytext+1); // Skip %
17791908 return VAR_ID;
17801909 }
17811910 YY_BREAK
1782 case 108:
1783 YY_RULE_SETUP
1784 #line 311 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1911 case 122:
1912 YY_RULE_SETUP
1913 #line 336 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17851914 {
17861915 yytext[strlen(yytext)-1] = 0; // nuke colon
17871916 UnEscapeLexed(yytext);
17891918 return LABELSTR;
17901919 }
17911920 YY_BREAK
1792 case 109:
1793 YY_RULE_SETUP
1794 #line 317 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1921 case 123:
1922 YY_RULE_SETUP
1923 #line 342 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
17951924 {
17961925 yytext[strlen(yytext)-2] = 0; // nuke colon, end quote
17971926 UnEscapeLexed(yytext+1);
17991928 return LABELSTR;
18001929 }
18011930 YY_BREAK
1802 case 110:
1803 YY_RULE_SETUP
1804 #line 324 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1931 case 124:
1932 YY_RULE_SETUP
1933 #line 349 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
18051934 { // Note that we cannot unescape a string constant here! The
18061935 // string constant might contain a \00 which would not be
18071936 // understood by the string stuff. It is valid to make a
18121941 return STRINGCONSTANT;
18131942 }
18141943 YY_BREAK
1815 case 111:
1816 YY_RULE_SETUP
1817 #line 335 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1944 case 125:
1945 YY_RULE_SETUP
1946 #line 360 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
18181947 { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
18191948 YY_BREAK
1820 case 112:
1821 YY_RULE_SETUP
1822 #line 336 "/Users/sabre/cvs/llvm/lib/AsmParser/Lexer.l"
1949 case 126:
1950 YY_RULE_SETUP
1951 #line 361 "/proj/llvm/llvm-1/lib/AsmParser/Lexer.l"
18231952 {
18241953 uint64_t Val = atoull(yytext+1);
1825