// This class also provides subclasses with typesafe implementations of methods
// so that don't have to do type casting.
//
+namespace {
template<class ArgType, class SubClassName>
class TemplateRules : public ConstRules {
public:
virtual ~TemplateRules() {}
};
-
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
//
// EmptyRules provides a concrete base class of ConstRules that does nothing
//
+namespace {
struct EmptyRules : public TemplateRules<Constant, EmptyRules> {
static Constant *EqualTo(const Constant *V1, const Constant *V2) {
if (V1 == V2) return ConstantBool::True;
return 0;
}
};
+} // end anonymous namespace
//
// BoolRules provides a concrete base class of ConstRules for the 'bool' type.
//
+namespace {
struct BoolRules : public TemplateRules<ConstantBool, BoolRules> {
static Constant *LessThan(const ConstantBool *V1, const ConstantBool *V2) {
DEF_CAST(Double, ConstantFP , double)
#undef DEF_CAST
};
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
// NullPointerRules provides a concrete base class of ConstRules for null
// pointers.
//
+namespace {
struct NullPointerRules : public TemplateRules<ConstantPointerNull,
NullPointerRules> {
static Constant *EqualTo(const Constant *V1, const Constant *V2) {
return ConstantPointerNull::get(PTy);
}
};
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
// ConstantPackedRules Class
/// PackedTypeRules provides a concrete base class of ConstRules for
/// ConstantPacked operands.
///
+namespace {
struct ConstantPackedRules
: public TemplateRules<ConstantPacked, ConstantPackedRules> {
return 0;
}
};
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
/// PackedType operands, where both operands are not ConstantPacked. The usual
/// cause for this is that one operand is a ConstantAggregateZero.
///
+namespace {
struct GeneralPackedRules : public TemplateRules<Constant, GeneralPackedRules> {
};
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
// different types. This allows the C++ compiler to automatically generate our
// constant handling operations in a typesafe and accurate manner.
//
+namespace {
template<class ConstantClass, class BuiltinType, Type **Ty, class SuperClass>
struct DirectRules : public TemplateRules<ConstantClass, SuperClass> {
static Constant *Add(const ConstantClass *V1, const ConstantClass *V2) {
DEF_CAST(Double, ConstantFP , double)
#undef DEF_CAST
};
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
// DirectIntRules provides implementations of functions that are valid on
// integer types, but not all types in general.
//
+namespace {
template <class ConstantClass, class BuiltinType, Type **Ty>
struct DirectIntRules
: public DirectRules<ConstantClass, BuiltinType, Ty,
return ConstantClass::get(*Ty, R);
}
};
+} // end anonymous namespace
//===----------------------------------------------------------------------===//
/// DirectFPRules provides implementations of functions that are valid on
/// floating point types, but not all types in general.
///
+namespace {
template <class ConstantClass, class BuiltinType, Type **Ty>
struct DirectFPRules
: public DirectRules<ConstantClass, BuiltinType, Ty,
return ConstantClass::get(*Ty, R);
}
};
+} // end anonymous namespace
/// ConstRules::get - This method returns the constant rules implementation that