mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-19 19:29:31 +00:00
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2 91177308-0d34-0410-b5e6-96231b3b80d8
198 lines
7.9 KiB
C++
198 lines
7.9 KiB
C++
//===- ConstantHandling.cpp - Implement ConstantHandling.h ----------------===//
|
|
//
|
|
// This file implements the various intrinsic operations, on constant values.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Opt/ConstantHandling.h"
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// TemplateRules Class
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// TemplateRules - Implement a subclass of ConstRules that provides all
|
|
// operations as noops. All other rules classes inherit from this class so
|
|
// that if functionality is needed in the future, it can simply be added here
|
|
// and to ConstRules without changing anything else...
|
|
//
|
|
// This class also provides subclasses with typesafe implementations of methods
|
|
// so that don't have to do type casting.
|
|
//
|
|
template<class ArgType, class SubClassName>
|
|
class TemplateRules : public ConstRules {
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Redirecting functions that cast to the appropriate types
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
virtual ConstPoolVal *neg(const ConstPoolVal *V) const {
|
|
return SubClassName::Neg((const ArgType *)V);
|
|
}
|
|
|
|
virtual ConstPoolVal *not(const ConstPoolVal *V) const {
|
|
return SubClassName::Not((const ArgType *)V);
|
|
}
|
|
|
|
|
|
virtual ConstPoolVal *add(const ConstPoolVal *V1,
|
|
const ConstPoolVal *V2) const {
|
|
return SubClassName::Add((const ArgType *)V1, (const ArgType *)V2);
|
|
}
|
|
|
|
virtual ConstPoolVal *sub(const ConstPoolVal *V1,
|
|
const ConstPoolVal *V2) const {
|
|
return SubClassName::Sub((const ArgType *)V1, (const ArgType *)V2);
|
|
}
|
|
|
|
virtual ConstPoolBool *lessthan(const ConstPoolVal *V1,
|
|
const ConstPoolVal *V2) const {
|
|
return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2);
|
|
}
|
|
|
|
//===--------------------------------------------------------------------===//
|
|
// Default "noop" implementations
|
|
//===--------------------------------------------------------------------===//
|
|
|
|
inline static ConstPoolVal *Neg(const ArgType *V) { return 0; }
|
|
inline static ConstPoolVal *Not(const ArgType *V) { return 0; }
|
|
|
|
inline static ConstPoolVal *Add(const ArgType *V1, const ArgType *V2) {
|
|
return 0;
|
|
}
|
|
|
|
inline static ConstPoolVal *Sub(const ArgType *V1, const ArgType *V2) {
|
|
return 0;
|
|
}
|
|
|
|
inline static ConstPoolBool *LessThan(const ArgType *V1, const ArgType *V2) {
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// EmptyRules Class
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// EmptyRules provides a concrete base class of ConstRules that does nothing
|
|
//
|
|
static // EmptyInst is static
|
|
struct EmptyRules : public TemplateRules<ConstPoolVal, EmptyRules> {
|
|
} EmptyInst;
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// BoolRules Class
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// BoolRules provides a concrete base class of ConstRules for the 'bool' type.
|
|
//
|
|
static // BoolTyInst is static...
|
|
struct BoolRules : public TemplateRules<ConstPoolBool, BoolRules> {
|
|
|
|
inline static ConstPoolVal *Not(const ConstPoolBool *V) {
|
|
return new ConstPoolBool(!V->getValue());
|
|
}
|
|
|
|
inline static ConstPoolVal *Or(const ConstPoolBool *V1,
|
|
const ConstPoolBool *V2) {
|
|
bool Result = V1->getValue() | V2->getValue();
|
|
return new ConstPoolBool(Result);
|
|
}
|
|
|
|
inline static ConstPoolVal *And(const ConstPoolBool *V1,
|
|
const ConstPoolBool *V2) {
|
|
bool Result = V1->getValue() & V2->getValue();
|
|
return new ConstPoolBool(Result);
|
|
}
|
|
} BoolTyInst;
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DirectRules Class
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// DirectRules provides a concrete base classes of ConstRules for a variety of
|
|
// different types. This allows the C++ compiler to automatically generate our
|
|
// constant handling operations in a typesafe and accurate manner.
|
|
//
|
|
template<class ConstPoolClass, class BuiltinType, const Type **Ty>
|
|
struct DirectRules
|
|
: public TemplateRules<ConstPoolClass,
|
|
DirectRules<ConstPoolClass, BuiltinType, Ty> > {
|
|
|
|
inline static ConstPoolVal *Neg(const ConstPoolClass *V) {
|
|
return new ConstPoolClass(*Ty, -(BuiltinType)V->getValue());;
|
|
}
|
|
inline static ConstPoolVal *Not(const ConstPoolClass *V) {
|
|
return new ConstPoolClass(*Ty, !(BuiltinType)V->getValue());;
|
|
}
|
|
|
|
inline static ConstPoolVal *Add(const ConstPoolClass *V1,
|
|
const ConstPoolClass *V2) {
|
|
BuiltinType Result = (BuiltinType)V1->getValue() +
|
|
(BuiltinType)V2->getValue();
|
|
return new ConstPoolClass(*Ty, Result);
|
|
}
|
|
|
|
inline static ConstPoolVal *Sub(const ConstPoolClass *V1,
|
|
const ConstPoolClass *V2) {
|
|
BuiltinType Result = (BuiltinType)V1->getValue() -
|
|
(BuiltinType)V2->getValue();
|
|
return new ConstPoolClass(*Ty, Result);
|
|
}
|
|
|
|
inline static ConstPoolBool *LessThan(const ConstPoolClass *V1,
|
|
const ConstPoolClass *V2) {
|
|
bool Result = (BuiltinType)V1->getValue() < (BuiltinType)V2->getValue();
|
|
return new ConstPoolBool(Result);
|
|
}
|
|
};
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// DirectRules Subclasses
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Given the DirectRules class we can now implement lots of types with little
|
|
// code. Thank goodness C++ compilers are great at stomping out layers of
|
|
// templates... can you imagine having to do this all by hand? (/me is lazy :)
|
|
//
|
|
static DirectRules<ConstPoolSInt, signed char , &Type::SByteTy> SByteTyInst;
|
|
static DirectRules<ConstPoolUInt, unsigned char , &Type::UByteTy> UByteTyInst;
|
|
static DirectRules<ConstPoolSInt, signed short, &Type::ShortTy> ShortTyInst;
|
|
static DirectRules<ConstPoolUInt, unsigned short, &Type::UShortTy> UShortTyInst;
|
|
static DirectRules<ConstPoolSInt, signed int , &Type::IntTy> IntTyInst;
|
|
static DirectRules<ConstPoolUInt, unsigned int , &Type::UIntTy> UIntTyInst;
|
|
static DirectRules<ConstPoolSInt, int64_t , &Type::LongTy> LongTyInst;
|
|
static DirectRules<ConstPoolUInt, uint64_t , &Type::ULongTy> ULongTyInst;
|
|
static DirectRules<ConstPoolFP , float , &Type::FloatTy> FloatTyInst;
|
|
static DirectRules<ConstPoolFP , double , &Type::DoubleTy> DoubleTyInst;
|
|
|
|
|
|
// ConstRules::find - Return the constant rules that take care of the specified
|
|
// type. Note that this is cached in the Type value itself, so switch statement
|
|
// is only hit at most once per type.
|
|
//
|
|
const ConstRules *ConstRules::find(const Type *Ty) {
|
|
const ConstRules *Result;
|
|
switch (Ty->getPrimitiveID()) {
|
|
case Type::BoolTyID: Result = &BoolTyInst; break;
|
|
case Type::SByteTyID: Result = &SByteTyInst; break;
|
|
case Type::UByteTyID: Result = &UByteTyInst; break;
|
|
case Type::ShortTyID: Result = &ShortTyInst; break;
|
|
case Type::UShortTyID: Result = &UShortTyInst; break;
|
|
case Type::IntTyID: Result = &IntTyInst; break;
|
|
case Type::UIntTyID: Result = &UIntTyInst; break;
|
|
case Type::LongTyID: Result = &LongTyInst; break;
|
|
case Type::ULongTyID: Result = &ULongTyInst; break;
|
|
case Type::FloatTyID: Result = &FloatTyInst; break;
|
|
case Type::DoubleTyID: Result = &DoubleTyInst; break;
|
|
default: Result = &EmptyInst; break;
|
|
}
|
|
|
|
Ty->setConstRules(Result); // Cache the value for future short circuiting!
|
|
return Result;
|
|
}
|