1 //===- ConstantHandling.cpp - Implement ConstantHandling.h ----------------===//
3 // This file implements the various intrinsic operations, on constant values.
5 //===----------------------------------------------------------------------===//
7 #include "llvm/ConstantHandling.h"
8 #include "llvm/iPHINode.h"
9 #include "llvm/DerivedTypes.h"
12 AnnotationID ConstRules::AID(AnnotationManager::getID("opt::ConstRules",
15 // ConstantFoldInstruction - Attempt to constant fold the specified instruction.
16 // If successful, the constant result is returned, if not, null is returned.
18 Constant *ConstantFoldInstruction(Instruction *I) {
19 if (PHINode *PN = dyn_cast<PHINode>(I)) {
20 if (PN->getNumIncomingValues() == 0)
21 return Constant::getNullValue(PN->getType());
23 Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0));
24 if (Result == 0) return 0;
26 // Handle PHI nodes specially here...
27 for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i)
28 if (PN->getIncomingValue(i) != Result)
29 return 0; // Not all the same incoming constants...
31 // If we reach here, all incoming values are the same constant.
38 if (I->getNumOperands() != 0) { // Get first operand if it's a constant...
39 Op0 = dyn_cast<Constant>(I->getOperand(0));
40 if (Op0 == 0) return 0; // Not a constant?, can't fold
42 if (I->getNumOperands() != 1) { // Get second operand if it's a constant...
43 Op1 = dyn_cast<Constant>(I->getOperand(1));
44 if (Op1 == 0) return 0; // Not a constant?, can't fold
48 switch (I->getOpcode()) {
49 case Instruction::Cast:
50 return ConstRules::get(*Op0, *Op0)->castTo(Op0, I->getType());
51 case Instruction::Add: return *Op0 + *Op1;
52 case Instruction::Sub: return *Op0 - *Op1;
53 case Instruction::Mul: return *Op0 * *Op1;
54 case Instruction::Div: return *Op0 / *Op1;
55 case Instruction::Rem: return *Op0 % *Op1;
56 case Instruction::And: return *Op0 & *Op1;
57 case Instruction::Or: return *Op0 | *Op1;
58 case Instruction::Xor: return *Op0 ^ *Op1;
60 case Instruction::SetEQ: return *Op0 == *Op1;
61 case Instruction::SetNE: return *Op0 != *Op1;
62 case Instruction::SetLE: return *Op0 <= *Op1;
63 case Instruction::SetGE: return *Op0 >= *Op1;
64 case Instruction::SetLT: return *Op0 < *Op1;
65 case Instruction::SetGT: return *Op0 > *Op1;
66 case Instruction::Shl: return *Op0 << *Op1;
67 case Instruction::Shr: return *Op0 >> *Op1;
68 case Instruction::GetElementPtr: {
69 std::vector<Constant*> IdxList;
70 IdxList.reserve(I->getNumOperands()-1);
71 if (Op1) IdxList.push_back(Op1);
72 for (unsigned i = 2, e = I->getNumOperands(); i != e; ++i)
73 if (Constant *C = dyn_cast<Constant>(I->getOperand(i)))
76 return 0; // Non-constant operand
77 return ConstantFoldGetElementPtr(Op0, IdxList);
84 static unsigned getSize(const Type *Ty) {
85 unsigned S = Ty->getPrimitiveSize();
86 return S ? S : 8; // Treat pointers at 8 bytes
89 Constant *ConstantFoldCastInstruction(const Constant *V, const Type *DestTy) {
90 if (V->getType() == DestTy) return (Constant*)V;
92 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
93 if (CE->getOpcode() == Instruction::Cast) {
94 Constant *Op = const_cast<Constant*>(CE->getOperand(0));
95 // Try to not produce a cast of a cast, which is almost always redundant.
96 if (!Op->getType()->isFloatingPoint() &&
97 !CE->getType()->isFloatingPoint() &&
98 !DestTy->getType()->isFloatingPoint()) {
99 unsigned S1 = getSize(Op->getType()), S2 = getSize(CE->getType());
100 unsigned S3 = getSize(DestTy);
101 if (Op->getType() == DestTy && S3 >= S2)
103 if (S1 >= S2 && S2 >= S3)
104 return ConstantExpr::getCast(Op, DestTy);
105 if (S1 <= S2 && S2 >= S3 && S1 <= S3)
106 return ConstantExpr::getCast(Op, DestTy);
110 return ConstRules::get(*V, *V)->castTo(V, DestTy);
113 Constant *ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *V1,
114 const Constant *V2) {
116 case Instruction::Add: return *V1 + *V2;
117 case Instruction::Sub: return *V1 - *V2;
118 case Instruction::Mul: return *V1 * *V2;
119 case Instruction::Div: return *V1 / *V2;
120 case Instruction::Rem: return *V1 % *V2;
121 case Instruction::And: return *V1 & *V2;
122 case Instruction::Or: return *V1 | *V2;
123 case Instruction::Xor: return *V1 ^ *V2;
125 case Instruction::SetEQ: return *V1 == *V2;
126 case Instruction::SetNE: return *V1 != *V2;
127 case Instruction::SetLE: return *V1 <= *V2;
128 case Instruction::SetGE: return *V1 >= *V2;
129 case Instruction::SetLT: return *V1 < *V2;
130 case Instruction::SetGT: return *V1 > *V2;
135 Constant *ConstantFoldShiftInstruction(unsigned Opcode, const Constant *V1,
136 const Constant *V2) {
138 case Instruction::Shl: return *V1 << *V2;
139 case Instruction::Shr: return *V1 >> *V2;
144 Constant *ConstantFoldGetElementPtr(const Constant *C,
145 const std::vector<Constant*> &IdxList) {
146 if (IdxList.size() == 0 ||
147 (IdxList.size() == 1 && IdxList[0]->isNullValue()))
148 return const_cast<Constant*>(C);
150 // If C is null and all idx's are null, return null of the right type.
152 // FIXME: Implement folding of GEP constant exprs the same as instcombine does
154 // Implement folding of:
155 // int* getelementptr ([2 x int]* cast ([3 x int]* %X to [2 x int]*),
157 // To: int* getelementptr ([3 x int]* %X, long 0, long 0)
159 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
160 if (CE->getOpcode() == Instruction::Cast && IdxList.size() > 1 &&
161 IdxList[0]->isNullValue())
162 if (const PointerType *SPT =
163 dyn_cast<PointerType>(CE->getOperand(0)->getType()))
164 if (const ArrayType *SAT = dyn_cast<ArrayType>(SPT->getElementType()))
165 if (const ArrayType *CAT =
166 dyn_cast<ArrayType>(cast<PointerType>(C->getType())->getElementType()))
167 if (CAT->getElementType() == SAT->getElementType())
168 return ConstantExpr::getGetElementPtr(
169 (Constant*)CE->getOperand(0), IdxList);
174 //===----------------------------------------------------------------------===//
175 // TemplateRules Class
176 //===----------------------------------------------------------------------===//
178 // TemplateRules - Implement a subclass of ConstRules that provides all
179 // operations as noops. All other rules classes inherit from this class so
180 // that if functionality is needed in the future, it can simply be added here
181 // and to ConstRules without changing anything else...
183 // This class also provides subclasses with typesafe implementations of methods
184 // so that don't have to do type casting.
186 template<class ArgType, class SubClassName>
187 class TemplateRules : public ConstRules {
189 //===--------------------------------------------------------------------===//
190 // Redirecting functions that cast to the appropriate types
191 //===--------------------------------------------------------------------===//
193 virtual Constant *add(const Constant *V1, const Constant *V2) const {
194 return SubClassName::Add((const ArgType *)V1, (const ArgType *)V2);
196 virtual Constant *sub(const Constant *V1, const Constant *V2) const {
197 return SubClassName::Sub((const ArgType *)V1, (const ArgType *)V2);
199 virtual Constant *mul(const Constant *V1, const Constant *V2) const {
200 return SubClassName::Mul((const ArgType *)V1, (const ArgType *)V2);
202 virtual Constant *div(const Constant *V1, const Constant *V2) const {
203 return SubClassName::Div((const ArgType *)V1, (const ArgType *)V2);
205 virtual Constant *rem(const Constant *V1, const Constant *V2) const {
206 return SubClassName::Rem((const ArgType *)V1, (const ArgType *)V2);
208 virtual Constant *op_and(const Constant *V1, const Constant *V2) const {
209 return SubClassName::And((const ArgType *)V1, (const ArgType *)V2);
211 virtual Constant *op_or(const Constant *V1, const Constant *V2) const {
212 return SubClassName::Or((const ArgType *)V1, (const ArgType *)V2);
214 virtual Constant *op_xor(const Constant *V1, const Constant *V2) const {
215 return SubClassName::Xor((const ArgType *)V1, (const ArgType *)V2);
217 virtual Constant *shl(const Constant *V1, const Constant *V2) const {
218 return SubClassName::Shl((const ArgType *)V1, (const ArgType *)V2);
220 virtual Constant *shr(const Constant *V1, const Constant *V2) const {
221 return SubClassName::Shr((const ArgType *)V1, (const ArgType *)V2);
224 virtual ConstantBool *lessthan(const Constant *V1,
225 const Constant *V2) const {
226 return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2);
229 // Casting operators. ick
230 virtual ConstantBool *castToBool(const Constant *V) const {
231 return SubClassName::CastToBool((const ArgType*)V);
233 virtual ConstantSInt *castToSByte(const Constant *V) const {
234 return SubClassName::CastToSByte((const ArgType*)V);
236 virtual ConstantUInt *castToUByte(const Constant *V) const {
237 return SubClassName::CastToUByte((const ArgType*)V);
239 virtual ConstantSInt *castToShort(const Constant *V) const {
240 return SubClassName::CastToShort((const ArgType*)V);
242 virtual ConstantUInt *castToUShort(const Constant *V) const {
243 return SubClassName::CastToUShort((const ArgType*)V);
245 virtual ConstantSInt *castToInt(const Constant *V) const {
246 return SubClassName::CastToInt((const ArgType*)V);
248 virtual ConstantUInt *castToUInt(const Constant *V) const {
249 return SubClassName::CastToUInt((const ArgType*)V);
251 virtual ConstantSInt *castToLong(const Constant *V) const {
252 return SubClassName::CastToLong((const ArgType*)V);
254 virtual ConstantUInt *castToULong(const Constant *V) const {
255 return SubClassName::CastToULong((const ArgType*)V);
257 virtual ConstantFP *castToFloat(const Constant *V) const {
258 return SubClassName::CastToFloat((const ArgType*)V);
260 virtual ConstantFP *castToDouble(const Constant *V) const {
261 return SubClassName::CastToDouble((const ArgType*)V);
263 virtual Constant *castToPointer(const Constant *V,
264 const PointerType *Ty) const {
265 return SubClassName::CastToPointer((const ArgType*)V, Ty);
268 //===--------------------------------------------------------------------===//
269 // Default "noop" implementations
270 //===--------------------------------------------------------------------===//
272 static Constant *Add(const ArgType *V1, const ArgType *V2) { return 0; }
273 static Constant *Sub(const ArgType *V1, const ArgType *V2) { return 0; }
274 static Constant *Mul(const ArgType *V1, const ArgType *V2) { return 0; }
275 static Constant *Div(const ArgType *V1, const ArgType *V2) { return 0; }
276 static Constant *Rem(const ArgType *V1, const ArgType *V2) { return 0; }
277 static Constant *And(const ArgType *V1, const ArgType *V2) { return 0; }
278 static Constant *Or (const ArgType *V1, const ArgType *V2) { return 0; }
279 static Constant *Xor(const ArgType *V1, const ArgType *V2) { return 0; }
280 static Constant *Shl(const ArgType *V1, const ArgType *V2) { return 0; }
281 static Constant *Shr(const ArgType *V1, const ArgType *V2) { return 0; }
282 static ConstantBool *LessThan(const ArgType *V1, const ArgType *V2) {
286 // Casting operators. ick
287 static ConstantBool *CastToBool (const Constant *V) { return 0; }
288 static ConstantSInt *CastToSByte (const Constant *V) { return 0; }
289 static ConstantUInt *CastToUByte (const Constant *V) { return 0; }
290 static ConstantSInt *CastToShort (const Constant *V) { return 0; }
291 static ConstantUInt *CastToUShort(const Constant *V) { return 0; }
292 static ConstantSInt *CastToInt (const Constant *V) { return 0; }
293 static ConstantUInt *CastToUInt (const Constant *V) { return 0; }
294 static ConstantSInt *CastToLong (const Constant *V) { return 0; }
295 static ConstantUInt *CastToULong (const Constant *V) { return 0; }
296 static ConstantFP *CastToFloat (const Constant *V) { return 0; }
297 static ConstantFP *CastToDouble(const Constant *V) { return 0; }
298 static Constant *CastToPointer(const Constant *,
299 const PointerType *) {return 0;}
304 //===----------------------------------------------------------------------===//
306 //===----------------------------------------------------------------------===//
308 // EmptyRules provides a concrete base class of ConstRules that does nothing
310 struct EmptyRules : public TemplateRules<Constant, EmptyRules> {
315 //===----------------------------------------------------------------------===//
317 //===----------------------------------------------------------------------===//
319 // BoolRules provides a concrete base class of ConstRules for the 'bool' type.
321 struct BoolRules : public TemplateRules<ConstantBool, BoolRules> {
323 static ConstantBool *LessThan(const ConstantBool *V1, const ConstantBool *V2){
324 return ConstantBool::get(V1->getValue() < V2->getValue());
327 static Constant *And(const ConstantBool *V1, const ConstantBool *V2) {
328 return ConstantBool::get(V1->getValue() & V2->getValue());
331 static Constant *Or(const ConstantBool *V1, const ConstantBool *V2) {
332 return ConstantBool::get(V1->getValue() | V2->getValue());
335 static Constant *Xor(const ConstantBool *V1, const ConstantBool *V2) {
336 return ConstantBool::get(V1->getValue() ^ V2->getValue());
341 //===----------------------------------------------------------------------===//
342 // PointerRules Class
343 //===----------------------------------------------------------------------===//
345 // PointerRules provides a concrete base class of ConstRules for pointer types
347 struct PointerRules : public TemplateRules<ConstantPointer, PointerRules> {
348 static ConstantBool *CastToBool (const Constant *V) {
349 if (V->isNullValue()) return ConstantBool::False;
350 return 0; // Can't const prop other types of pointers
352 static ConstantSInt *CastToSByte (const Constant *V) {
353 if (V->isNullValue()) return ConstantSInt::get(Type::SByteTy, 0);
354 return 0; // Can't const prop other types of pointers
356 static ConstantUInt *CastToUByte (const Constant *V) {
357 if (V->isNullValue()) return ConstantUInt::get(Type::UByteTy, 0);
358 return 0; // Can't const prop other types of pointers
360 static ConstantSInt *CastToShort (const Constant *V) {
361 if (V->isNullValue()) return ConstantSInt::get(Type::ShortTy, 0);
362 return 0; // Can't const prop other types of pointers
364 static ConstantUInt *CastToUShort(const Constant *V) {
365 if (V->isNullValue()) return ConstantUInt::get(Type::UShortTy, 0);
366 return 0; // Can't const prop other types of pointers
368 static ConstantSInt *CastToInt (const Constant *V) {
369 if (V->isNullValue()) return ConstantSInt::get(Type::IntTy, 0);
370 return 0; // Can't const prop other types of pointers
372 static ConstantUInt *CastToUInt (const Constant *V) {
373 if (V->isNullValue()) return ConstantUInt::get(Type::UIntTy, 0);
374 return 0; // Can't const prop other types of pointers
376 static ConstantSInt *CastToLong (const Constant *V) {
377 if (V->isNullValue()) return ConstantSInt::get(Type::LongTy, 0);
378 return 0; // Can't const prop other types of pointers
380 static ConstantUInt *CastToULong (const Constant *V) {
381 if (V->isNullValue()) return ConstantUInt::get(Type::ULongTy, 0);
382 return 0; // Can't const prop other types of pointers
384 static ConstantFP *CastToFloat (const Constant *V) {
385 if (V->isNullValue()) return ConstantFP::get(Type::FloatTy, 0);
386 return 0; // Can't const prop other types of pointers
388 static ConstantFP *CastToDouble(const Constant *V) {
389 if (V->isNullValue()) return ConstantFP::get(Type::DoubleTy, 0);
390 return 0; // Can't const prop other types of pointers
393 static Constant *CastToPointer(const ConstantPointer *V,
394 const PointerType *PTy) {
395 if (V->getType() == PTy)
396 return const_cast<ConstantPointer*>(V); // Allow cast %PTy %ptr to %PTy
397 if (V->isNullValue())
398 return ConstantPointerNull::get(PTy);
399 return 0; // Can't const prop other types of pointers
404 //===----------------------------------------------------------------------===//
406 //===----------------------------------------------------------------------===//
408 // DirectRules provides a concrete base classes of ConstRules for a variety of
409 // different types. This allows the C++ compiler to automatically generate our
410 // constant handling operations in a typesafe and accurate manner.
412 template<class ConstantClass, class BuiltinType, Type **Ty, class SuperClass>
413 struct DirectRules : public TemplateRules<ConstantClass, SuperClass> {
414 static Constant *Add(const ConstantClass *V1, const ConstantClass *V2) {
415 BuiltinType R = (BuiltinType)V1->getValue() + (BuiltinType)V2->getValue();
416 return ConstantClass::get(*Ty, R);
419 static Constant *Sub(const ConstantClass *V1, const ConstantClass *V2) {
420 BuiltinType R = (BuiltinType)V1->getValue() - (BuiltinType)V2->getValue();
421 return ConstantClass::get(*Ty, R);
424 static Constant *Mul(const ConstantClass *V1, const ConstantClass *V2) {
425 BuiltinType R = (BuiltinType)V1->getValue() * (BuiltinType)V2->getValue();
426 return ConstantClass::get(*Ty, R);
429 static Constant *Div(const ConstantClass *V1, const ConstantClass *V2) {
430 if (V2->isNullValue()) return 0;
431 BuiltinType R = (BuiltinType)V1->getValue() / (BuiltinType)V2->getValue();
432 return ConstantClass::get(*Ty, R);
435 static ConstantBool *LessThan(const ConstantClass *V1,
436 const ConstantClass *V2) {
437 bool R = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue();
438 return ConstantBool::get(R);
441 static Constant *CastToPointer(const ConstantClass *V,
442 const PointerType *PTy) {
443 if (V->isNullValue()) // Is it a FP or Integral null value?
444 return ConstantPointerNull::get(PTy);
445 return 0; // Can't const prop other types of pointers
448 // Casting operators. ick
449 #define DEF_CAST(TYPE, CLASS, CTYPE) \
450 static CLASS *CastTo##TYPE (const ConstantClass *V) { \
451 return CLASS::get(Type::TYPE##Ty, (CTYPE)(BuiltinType)V->getValue()); \
454 DEF_CAST(Bool , ConstantBool, bool)
455 DEF_CAST(SByte , ConstantSInt, signed char)
456 DEF_CAST(UByte , ConstantUInt, unsigned char)
457 DEF_CAST(Short , ConstantSInt, signed short)
458 DEF_CAST(UShort, ConstantUInt, unsigned short)
459 DEF_CAST(Int , ConstantSInt, signed int)
460 DEF_CAST(UInt , ConstantUInt, unsigned int)
461 DEF_CAST(Long , ConstantSInt, int64_t)
462 DEF_CAST(ULong , ConstantUInt, uint64_t)
463 DEF_CAST(Float , ConstantFP , float)
464 DEF_CAST(Double, ConstantFP , double)
469 //===----------------------------------------------------------------------===//
470 // DirectIntRules Class
471 //===----------------------------------------------------------------------===//
473 // DirectIntRules provides implementations of functions that are valid on
474 // integer types, but not all types in general.
476 template <class ConstantClass, class BuiltinType, Type **Ty>
477 struct DirectIntRules
478 : public DirectRules<ConstantClass, BuiltinType, Ty,
479 DirectIntRules<ConstantClass, BuiltinType, Ty> > {
481 static Constant *Div(const ConstantClass *V1, const ConstantClass *V2) {
482 if (V2->isNullValue()) return 0;
483 if (V2->isAllOnesValue() && // MIN_INT / -1
484 (BuiltinType)V1->getValue() == -(BuiltinType)V1->getValue())
486 BuiltinType R = (BuiltinType)V1->getValue() / (BuiltinType)V2->getValue();
487 return ConstantClass::get(*Ty, R);
490 static Constant *Rem(const ConstantClass *V1,
491 const ConstantClass *V2) {
492 if (V2->isNullValue()) return 0; // X / 0
493 if (V2->isAllOnesValue() && // MIN_INT / -1
494 (BuiltinType)V1->getValue() == -(BuiltinType)V1->getValue())
496 BuiltinType R = (BuiltinType)V1->getValue() % (BuiltinType)V2->getValue();
497 return ConstantClass::get(*Ty, R);
500 static Constant *And(const ConstantClass *V1, const ConstantClass *V2) {
501 BuiltinType R = (BuiltinType)V1->getValue() & (BuiltinType)V2->getValue();
502 return ConstantClass::get(*Ty, R);
504 static Constant *Or(const ConstantClass *V1, const ConstantClass *V2) {
505 BuiltinType R = (BuiltinType)V1->getValue() | (BuiltinType)V2->getValue();
506 return ConstantClass::get(*Ty, R);
508 static Constant *Xor(const ConstantClass *V1, const ConstantClass *V2) {
509 BuiltinType R = (BuiltinType)V1->getValue() ^ (BuiltinType)V2->getValue();
510 return ConstantClass::get(*Ty, R);
513 static Constant *Shl(const ConstantClass *V1, const ConstantClass *V2) {
514 BuiltinType R = (BuiltinType)V1->getValue() << (BuiltinType)V2->getValue();
515 return ConstantClass::get(*Ty, R);
518 static Constant *Shr(const ConstantClass *V1, const ConstantClass *V2) {
519 BuiltinType R = (BuiltinType)V1->getValue() >> (BuiltinType)V2->getValue();
520 return ConstantClass::get(*Ty, R);
525 //===----------------------------------------------------------------------===//
526 // DirectFPRules Class
527 //===----------------------------------------------------------------------===//
529 // DirectFPRules provides implementations of functions that are valid on
530 // floating point types, but not all types in general.
532 template <class ConstantClass, class BuiltinType, Type **Ty>
534 : public DirectRules<ConstantClass, BuiltinType, Ty,
535 DirectFPRules<ConstantClass, BuiltinType, Ty> > {
536 static Constant *Rem(const ConstantClass *V1, const ConstantClass *V2) {
537 if (V2->isNullValue()) return 0;
538 BuiltinType Result = std::fmod((BuiltinType)V1->getValue(),
539 (BuiltinType)V2->getValue());
540 return ConstantClass::get(*Ty, Result);
544 //===----------------------------------------------------------------------===//
545 // DirectRules Subclasses
546 //===----------------------------------------------------------------------===//
548 // Given the DirectRules class we can now implement lots of types with little
549 // code. Thank goodness C++ compilers are great at stomping out layers of
550 // templates... can you imagine having to do this all by hand? (/me is lazy :)
553 // ConstRules::find - Return the constant rules that take care of the specified
556 Annotation *ConstRules::find(AnnotationID AID, const Annotable *TyA, void *) {
557 assert(AID == ConstRules::AID && "Bad annotation for factory!");
558 const Type *Ty = cast<Type>((const Value*)TyA);
560 switch (Ty->getPrimitiveID()) {
561 case Type::BoolTyID: return new BoolRules();
562 case Type::PointerTyID: return new PointerRules();
563 case Type::SByteTyID:
564 return new DirectIntRules<ConstantSInt, signed char , &Type::SByteTy>();
565 case Type::UByteTyID:
566 return new DirectIntRules<ConstantUInt, unsigned char , &Type::UByteTy>();
567 case Type::ShortTyID:
568 return new DirectIntRules<ConstantSInt, signed short, &Type::ShortTy>();
569 case Type::UShortTyID:
570 return new DirectIntRules<ConstantUInt, unsigned short, &Type::UShortTy>();
572 return new DirectIntRules<ConstantSInt, signed int , &Type::IntTy>();
574 return new DirectIntRules<ConstantUInt, unsigned int , &Type::UIntTy>();
576 return new DirectIntRules<ConstantSInt, int64_t , &Type::LongTy>();
577 case Type::ULongTyID:
578 return new DirectIntRules<ConstantUInt, uint64_t , &Type::ULongTy>();
579 case Type::FloatTyID:
580 return new DirectFPRules<ConstantFP , float , &Type::FloatTy>();
581 case Type::DoubleTyID:
582 return new DirectFPRules<ConstantFP , double , &Type::DoubleTy>();
584 return new EmptyRules();
588 ConstRules *ConstRules::getConstantExprRules() {
589 static EmptyRules CERules;