6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-29 10:32:47 +00:00
Code Issues Projects Releases Wiki Activity

Implement == and != correctly. Before they would incorrectly return !=

Browse Source 
for some constant exprs when they could really be the same value


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10058 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-11-17 20:19:35 +00:00
parent 48babfa60d
commit 5d5a714b24
4 changed files with 60 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
include/llvm/ConstantHandling.h
View File

@ -47,19 +47,6 @@ namespace llvm {
class PointerType;
//===----------------------------------------------------------------------===//
// Implement == and != directly...
//===----------------------------------------------------------------------===//
inline ConstantBool *operator==(const Constant &V1, const Constant &V2) {
assert(V1.getType() == V2.getType() && "Constant types must be identical!");
return ConstantBool::get(&V1 == &V2);
}
inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) {
return ConstantBool::get(&V1 != &V2);
}
//===----------------------------------------------------------------------===//
// Implement all other operators indirectly through TypeRules system
//===----------------------------------------------------------------------===//
@ -81,6 +68,8 @@ struct ConstRules {
virtual ConstantBool *lessthan(const Constant *V1,
const Constant *V2) const = 0;
virtual ConstantBool *equalto(const Constant *V1,
const Constant *V2) const = 0;
// Casting operators. ick
virtual ConstantBool *castToBool (const Constant *V) const = 0;
@ -195,11 +184,21 @@ inline ConstantBool *operator<(const Constant &V1,
return ConstRules::get(V1, V2).lessthan(&V1, &V2);
}
inline ConstantBool *operator==(const Constant &V1, const Constant &V2) {
assert(V1.getType() == V2.getType() && "Constant types must be identical!");
return ConstRules::get(V1, V2).equalto(&V1, &V2);
}
//===----------------------------------------------------------------------===//
// Implement 'derived' operators based on what we already have...
//===----------------------------------------------------------------------===//
inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) {
if (ConstantBool *V = (V1 == V2))
return V->inverted(); // !(V1 == V2)
return 0;
}
inline ConstantBool *operator>(const Constant &V1,
const Constant &V2) {
return V2 < V1;

24
lib/VMCore/ConstantFold.cpp
View File

@ -256,6 +256,10 @@ class TemplateRules : public ConstRules {
const Constant *V2) const {
return SubClassName::LessThan((const ArgType *)V1, (const ArgType *)V2);
}
virtual ConstantBool *equalto(const Constant *V1,
const Constant *V2) const {
return SubClassName::EqualTo((const ArgType *)V1, (const ArgType *)V2);
}
// Casting operators. ick
virtual ConstantBool *castToBool(const Constant *V) const {
@ -313,6 +317,9 @@ class TemplateRules : public ConstRules {
static ConstantBool *LessThan(const ArgType *V1, const ArgType *V2) {
return 0;
}
static ConstantBool *EqualTo(const ArgType *V1, const ArgType *V2) {
return 0;
}
// Casting operators. ick
static ConstantBool *CastToBool (const Constant *V) { return 0; }
@ -339,6 +346,10 @@ class TemplateRules : public ConstRules {
// EmptyRules provides a concrete base class of ConstRules that does nothing
//
struct EmptyRules : public TemplateRules<Constant, EmptyRules> {
static ConstantBool *EqualTo(const Constant *V1, const Constant *V2) {
if (V1 == V2) return ConstantBool::True;
return 0;
}
};
@ -355,6 +366,10 @@ struct BoolRules : public TemplateRules<ConstantBool, BoolRules> {
return ConstantBool::get(V1->getValue() < V2->getValue());
}
static ConstantBool *EqualTo(const Constant *V1, const Constant *V2) {
return ConstantBool::get(V1 == V2);
}
static Constant *And(const ConstantBool *V1, const ConstantBool *V2) {
return ConstantBool::get(V1->getValue() & V2->getValue());
}
@ -397,6 +412,9 @@ struct BoolRules : public TemplateRules<ConstantBool, BoolRules> {
//
struct NullPointerRules : public TemplateRules<ConstantPointerNull,
NullPointerRules> {
static ConstantBool *EqualTo(const Constant *V1, const Constant *V2) {
return ConstantBool::True; // Null pointers are always equal
}
static ConstantBool *CastToBool (const Constant *V) {
return ConstantBool::False;
}
@ -475,6 +493,12 @@ struct DirectRules : public TemplateRules<ConstantClass, SuperClass> {
return ConstantBool::get(R);
}
static ConstantBool *EqualTo(const ConstantClass *V1,
const ConstantClass *V2) {
bool R = (BuiltinType)V1->getValue() == (BuiltinType)V2->getValue();
return ConstantBool::get(R);
}
static Constant *CastToPointer(const ConstantClass *V,
const PointerType *PTy) {
if (V->isNullValue()) // Is it a FP or Integral null value?

25
lib/VMCore/ConstantFold.h
View File

@ -47,19 +47,6 @@ namespace llvm {
class PointerType;
//===----------------------------------------------------------------------===//
// Implement == and != directly...
//===----------------------------------------------------------------------===//
inline ConstantBool *operator==(const Constant &V1, const Constant &V2) {
assert(V1.getType() == V2.getType() && "Constant types must be identical!");
return ConstantBool::get(&V1 == &V2);
}
inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) {
return ConstantBool::get(&V1 != &V2);
}
//===----------------------------------------------------------------------===//
// Implement all other operators indirectly through TypeRules system
//===----------------------------------------------------------------------===//
@ -81,6 +68,8 @@ struct ConstRules {
virtual ConstantBool *lessthan(const Constant *V1,
const Constant *V2) const = 0;
virtual ConstantBool *equalto(const Constant *V1,
const Constant *V2) const = 0;
// Casting operators. ick
virtual ConstantBool *castToBool (const Constant *V) const = 0;
@ -195,11 +184,21 @@ inline ConstantBool *operator<(const Constant &V1,
return ConstRules::get(V1, V2).lessthan(&V1, &V2);
}
inline ConstantBool *operator==(const Constant &V1, const Constant &V2) {
assert(V1.getType() == V2.getType() && "Constant types must be identical!");
return ConstRules::get(V1, V2).equalto(&V1, &V2);
}
//===----------------------------------------------------------------------===//
// Implement 'derived' operators based on what we already have...
//===----------------------------------------------------------------------===//
inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) {
if (ConstantBool *V = (V1 == V2))
return V->inverted(); // !(V1 == V2)
return 0;
}
inline ConstantBool *operator>(const Constant &V1,
const Constant &V2) {
return V2 < V1;

25
lib/VMCore/ConstantFolding.h
View File

@ -47,19 +47,6 @@ namespace llvm {
class PointerType;
//===----------------------------------------------------------------------===//
// Implement == and != directly...
//===----------------------------------------------------------------------===//
inline ConstantBool *operator==(const Constant &V1, const Constant &V2) {
assert(V1.getType() == V2.getType() && "Constant types must be identical!");
return ConstantBool::get(&V1 == &V2);
}
inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) {
return ConstantBool::get(&V1 != &V2);
}
//===----------------------------------------------------------------------===//
// Implement all other operators indirectly through TypeRules system
//===----------------------------------------------------------------------===//
@ -81,6 +68,8 @@ struct ConstRules {
virtual ConstantBool *lessthan(const Constant *V1,
const Constant *V2) const = 0;
virtual ConstantBool *equalto(const Constant *V1,
const Constant *V2) const = 0;
// Casting operators. ick
virtual ConstantBool *castToBool (const Constant *V) const = 0;
@ -195,11 +184,21 @@ inline ConstantBool *operator<(const Constant &V1,
return ConstRules::get(V1, V2).lessthan(&V1, &V2);
}
inline ConstantBool *operator==(const Constant &V1, const Constant &V2) {
assert(V1.getType() == V2.getType() && "Constant types must be identical!");
return ConstRules::get(V1, V2).equalto(&V1, &V2);
}
//===----------------------------------------------------------------------===//
// Implement 'derived' operators based on what we already have...
//===----------------------------------------------------------------------===//
inline ConstantBool *operator!=(const Constant &V1, const Constant &V2) {
if (ConstantBool *V = (V1 == V2))
return V->inverted(); // !(V1 == V2)
return 0;
}
inline ConstantBool *operator>(const Constant &V1,
const Constant &V2) {
return V2 < V1;