6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-12 17:32:19 +00:00
Code Issues Projects Releases Wiki Activity

Fix a regression I introduced back in r178147.

Browse Source 
We don't want cast and dyn_cast to work on temporaries. They don't extend
lifetime like a direct bind to a reference would, so they can introduce
hard to find bugs.

I added tests to make sure we don't regress this. Thanks to Eli Friedman for
noticing this and for his suggestions on how to test it.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@186559 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola 2013-07-18 02:42:40 +00:00
parent 717b3f02ff
commit 60f18ad8a5
2 changed files with 39 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
include/llvm/Support/Casting.h
View File

@ -206,7 +206,10 @@ template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
} }
}; };
template <class X> struct is_simple_type {
static const bool value =
is_same<X, typename simplify_type<X>::SimpleType>::value;
};
// cast<X> - Return the argument parameter cast to the specified type. This // cast<X> - Return the argument parameter cast to the specified type. This
// casting operator asserts that the type is correct, so it does not return null // casting operator asserts that the type is correct, so it does not return null
@ -216,10 +219,12 @@ template<class To, class FromTy> struct cast_convert_val<To,FromTy,FromTy> {
// cast<Instruction>(myVal)->getParent() // cast<Instruction>(myVal)->getParent()
// //
template <class X, class Y> template <class X, class Y>
inline typename cast_retty<X, const Y>::ret_type cast(const Y &Val) { inline typename enable_if_c<!is_simple_type<Y>::value,
typename cast_retty<X, const Y>::ret_type>::type
cast(const Y &Val) {
assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!"); assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
return cast_convert_val<X, const Y, return cast_convert_val<
typename simplify_type<const Y>::SimpleType>::doit(Val); X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
} }
template <class X, class Y> template <class X, class Y>
@ -230,10 +235,7 @@ inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
} }
template <class X, class Y> template <class X, class Y>
inline typename enable_if< inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
is_same<Y, typename simplify_type<Y>::SimpleType>,
typename cast_retty<X, Y*>::ret_type
>::type cast(Y *Val) {
assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!"); assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!");
return cast_convert_val<X, Y*, return cast_convert_val<X, Y*,
typename simplify_type<Y*>::SimpleType>::doit(Val); typename simplify_type<Y*>::SimpleType>::doit(Val);
@ -259,7 +261,9 @@ inline typename cast_retty<X, Y*>::ret_type cast_or_null(Y *Val) {
// //
template <class X, class Y> template <class X, class Y>
inline typename cast_retty<X, const Y>::ret_type dyn_cast(const Y &Val) { inline typename enable_if_c<!is_simple_type<Y>::value,
typename cast_retty<X, const Y>::ret_type>::type
dyn_cast(const Y &Val) {
return isa<X>(Val) ? cast<X>(Val) : 0; return isa<X>(Val) ? cast<X>(Val) : 0;
} }
@ -269,10 +273,7 @@ inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
} }
template <class X, class Y> template <class X, class Y>
inline typename enable_if< inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
is_same<Y, typename simplify_type<Y>::SimpleType>,
typename cast_retty<X, Y*>::ret_type
>::type dyn_cast(Y *Val) {
return isa<X>(Val) ? cast<X>(Val) : 0; return isa<X>(Val) ? cast<X>(Val) : 0;
} }

25
unittests/Support/Casting.cpp
View File

@ -10,10 +10,15 @@
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "llvm/IR/User.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <cstdlib> #include <cstdlib>
namespace llvm { namespace llvm {
// Used to test illegal cast. If a cast doesn't match any of the "real" ones,
// it will match this one.
struct IllegalCast;
template <typename T> IllegalCast *cast(...) { return 0; }
// set up two example classes // set up two example classes
// with conversion facility // with conversion facility
@ -60,10 +65,25 @@ foo *bar::naz() {
bar *fub(); bar *fub();
template <> struct simplify_type<foo> {
typedef int SimpleType;
static SimpleType getSimplifiedValue(foo &Val) { return 0; }
};
} // End llvm namespace } // End llvm namespace
using namespace llvm; using namespace llvm;
// Test the peculiar behavior of Use in simplify_type.
int Check1[is_same<simplify_type<Use>::SimpleType, Value *>::value ? 1 : -1];
int Check2[is_same<simplify_type<Use *>::SimpleType, Value *>::value ? 1 : -1];
// Test that a regular class behaves as expected.
int Check3[is_same<simplify_type<foo>::SimpleType, int>::value ? 1 : -1];
int Check4[is_same<simplify_type<foo *>::SimpleType, foo *>::value ? 1 : -1];
namespace { namespace {
const foo *null_foo = NULL; const foo *null_foo = NULL;
@ -203,3 +223,8 @@ TEST(CastingTest, InferredUpcastTakesPrecedence) {
} // end namespace inferred_upcasting } // end namespace inferred_upcasting
} // end anonymous namespace } // end anonymous namespace
// Test that we reject casts of temporaries (and so the illegal cast gets used).
namespace TemporaryCast {
struct pod {};
IllegalCast *testIllegalCast() { return cast<foo>(pod()); }
}