6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 04:33:05 +00:00
Code Issues Projects Releases Wiki Activity

Support constant casting constant pointers to ints/uints, and/or

Browse Source 
the other way around, instead of failing a large, tumor-like assertion.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10171 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Brian Gaeke 2003-11-22 07:18:25 +00:00
parent dfcc9cfaa8
commit f9c86cf5cf
2 changed files with 16 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
lib/Target/X86/Printer.cpp
View File

@ -185,15 +185,19 @@ void Printer::emitConstantValueOnly(const Constant *CV) {
} }
case Instruction::Cast: { case Instruction::Cast: {
// Support only non-converting or widening casts for now, that is, ones // Support only non-converting or widening casts for now, that is, ones
// that do not involve a change in value. This assertion is not a // that do not involve a change in value. This assertion is really gross,
// complete check. // and may not even be a complete check.
Constant *Op = CE->getOperand(0); Constant *Op = CE->getOperand(0);
const Type *OpTy = Op->getType(), *Ty = CE->getType(); const Type *OpTy = Op->getType(), *Ty = CE->getType();
// Remember, kids, pointers on x86 can be losslessly converted back and
// forth into 32-bit or wider integers, regardless of signedness. :-P
assert(((isa<PointerType>(OpTy) assert(((isa<PointerType>(OpTy)
&& (Ty == Type::LongTy || Ty == Type::ULongTy)) && (Ty == Type::LongTy || Ty == Type::ULongTy
|| Ty == Type::IntTy || Ty == Type::UIntTy))
|| (isa<PointerType>(Ty) || (isa<PointerType>(Ty)
&& (OpTy == Type::LongTy || OpTy == Type::ULongTy)) && (OpTy == Type::LongTy || OpTy == Type::ULongTy
|| OpTy == Type::IntTy || OpTy == Type::UIntTy))
|| (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy)) || (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy))
&& OpTy->isLosslesslyConvertibleTo(Ty)))) && OpTy->isLosslesslyConvertibleTo(Ty))))
&& "FIXME: Don't yet support this kind of constant cast expr"); && "FIXME: Don't yet support this kind of constant cast expr");

12
lib/Target/X86/X86AsmPrinter.cpp
View File

@ -185,15 +185,19 @@ void Printer::emitConstantValueOnly(const Constant *CV) {
} }
case Instruction::Cast: { case Instruction::Cast: {
// Support only non-converting or widening casts for now, that is, ones // Support only non-converting or widening casts for now, that is, ones
// that do not involve a change in value. This assertion is not a // that do not involve a change in value. This assertion is really gross,
// complete check. // and may not even be a complete check.
Constant *Op = CE->getOperand(0); Constant *Op = CE->getOperand(0);
const Type *OpTy = Op->getType(), *Ty = CE->getType(); const Type *OpTy = Op->getType(), *Ty = CE->getType();
// Remember, kids, pointers on x86 can be losslessly converted back and
// forth into 32-bit or wider integers, regardless of signedness. :-P
assert(((isa<PointerType>(OpTy) assert(((isa<PointerType>(OpTy)
&& (Ty == Type::LongTy || Ty == Type::ULongTy)) && (Ty == Type::LongTy || Ty == Type::ULongTy
|| Ty == Type::IntTy || Ty == Type::UIntTy))
|| (isa<PointerType>(Ty) || (isa<PointerType>(Ty)
&& (OpTy == Type::LongTy || OpTy == Type::ULongTy)) && (OpTy == Type::LongTy || OpTy == Type::ULongTy
|| OpTy == Type::IntTy || OpTy == Type::UIntTy))
|| (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy)) || (((TD.getTypeSize(Ty) >= TD.getTypeSize(OpTy))
&& OpTy->isLosslesslyConvertibleTo(Ty)))) && OpTy->isLosslesslyConvertibleTo(Ty))))
&& "FIXME: Don't yet support this kind of constant cast expr"); && "FIXME: Don't yet support this kind of constant cast expr");