andreybokhanko updated this revision to Diff 46908. andreybokhanko added a comment.
John, thank you for the review! I refactored EvaluateBuiltinClassifyType according to your comments; please re-review. Yours, Andrey http://reviews.llvm.org/D16846 Files: lib/AST/ExprConstant.cpp test/Sema/builtin-classify-type.c test/SemaCXX/builtin-classify-type.cpp
Index: lib/AST/ExprConstant.cpp =================================================================== --- lib/AST/ExprConstant.cpp +++ lib/AST/ExprConstant.cpp @@ -6185,7 +6185,8 @@ /// EvaluateBuiltinClassifyType - Evaluate __builtin_classify_type the same way /// as GCC. -static int EvaluateBuiltinClassifyType(const CallExpr *E) { +static int EvaluateBuiltinClassifyType(const CallExpr *E, + const LangOptions &LangOpts) { // The following enum mimics the values returned by GCC. // FIXME: Does GCC differ between lvalue and rvalue references here? enum gcc_type_class { @@ -6205,37 +6206,88 @@ if (E->getNumArgs() == 0) return no_type_class; - QualType ArgTy = E->getArg(0)->getType(); - if (ArgTy->isVoidType()) - return void_type_class; - else if (ArgTy->isEnumeralType()) - return enumeral_type_class; - else if (ArgTy->isBooleanType()) - return boolean_type_class; - else if (ArgTy->isCharType()) - return string_type_class; // gcc doesn't appear to use char_type_class - else if (ArgTy->isIntegerType()) - return integer_type_class; - else if (ArgTy->isPointerType()) + QualType CanTy = E->getArg(0)->getType().getCanonicalType(); + const BuiltinType *BT = dyn_cast<BuiltinType>(CanTy); + + switch (CanTy->getTypeClass()) { + case Type::Builtin: + switch (BT->getKind()) { + case BuiltinType::Void: + return void_type_class; + + case BuiltinType::Bool: + return boolean_type_class; + + case BuiltinType::Char_S: // gcc doesn't appear to use char_type_class + case BuiltinType::Char_U: + case BuiltinType::SChar: + case BuiltinType::UChar: + case BuiltinType::UShort: + case BuiltinType::Short: + case BuiltinType::Half: + case BuiltinType::Int: + case BuiltinType::UInt: + case BuiltinType::Long: + case BuiltinType::ULong: + case BuiltinType::LongLong: + case BuiltinType::ULongLong: + case BuiltinType::Int128: + case BuiltinType::UInt128: + return integer_type_class; + + case BuiltinType::NullPtr: + return pointer_type_class; + + case BuiltinType::Float: + case BuiltinType::Double: + case BuiltinType::LongDouble: + return real_type_class; + + default: + break; + }; + + case Type::Enum: + return LangOpts.CPlusPlus ? enumeral_type_class : integer_type_class; + break; + + case Type::Pointer: return pointer_type_class; - else if (ArgTy->isReferenceType()) - return reference_type_class; - else if (ArgTy->isRealType()) - return real_type_class; - else if (ArgTy->isComplexType()) + break; + + case Type::MemberPointer: + if (CanTy->isMemberDataPointerType()) + return offset_type_class; + else if (CanTy->isMemberFunctionPointerType()) + return method_type_class; + break; + + case Type::Complex: return complex_type_class; - else if (ArgTy->isFunctionType()) - return function_type_class; - else if (ArgTy->isStructureOrClassType()) - return record_type_class; - else if (ArgTy->isUnionType()) - return union_type_class; - else if (ArgTy->isArrayType()) - return array_type_class; - else if (ArgTy->isUnionType()) - return union_type_class; - else // FIXME: offset_type_class, method_type_class, & lang_type_class? - llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type"); + + case Type::FunctionNoProto: + case Type::FunctionProto: + return LangOpts.CPlusPlus ? function_type_class : pointer_type_class; + + case Type::Record: + if (CanTy->isStructureOrClassType()) + return record_type_class; + else if (CanTy->isUnionType()) + return union_type_class; + break; + + case Type::ConstantArray: + case Type::VariableArray: + case Type::IncompleteArray: + case Type::DependentSizedArray: + return LangOpts.CPlusPlus ? array_type_class : pointer_type_class; + + default: + break; + } + + // FIXME: string_type_class & lang_type_class? + llvm_unreachable("CallExpr::isBuiltinClassifyType(): unimplemented type"); } /// EvaluateBuiltinConstantPForLValue - Determine the result of @@ -6607,7 +6659,7 @@ } case Builtin::BI__builtin_classify_type: - return Success(EvaluateBuiltinClassifyType(E), E); + return Success(EvaluateBuiltinClassifyType(E, Info.getLangOpts()), E); // FIXME: BI__builtin_clrsb // FIXME: BI__builtin_clrsbl Index: test/SemaCXX/builtin-classify-type.cpp =================================================================== --- test/SemaCXX/builtin-classify-type.cpp +++ test/SemaCXX/builtin-classify-type.cpp @@ -0,0 +1,54 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// expected-no-diagnostics + +enum gcc_type_class { + no_type_class = -1, + void_type_class, integer_type_class, char_type_class, + enumeral_type_class, boolean_type_class, + pointer_type_class, reference_type_class, offset_type_class, + real_type_class, complex_type_class, + function_type_class, method_type_class, + record_type_class, union_type_class, + array_type_class, string_type_class, + lang_type_class +}; + +class cl { +public: + void bar() {} + int baz; +}; + +int builtin_result; + +void foo() { + int i; + char c; + enum { red, green, blue} enum_obj; + bool b; + int *p; + int &r = i; + double d; + extern void f(); + cl cl_obj; + union { int a; float b; } u_obj; + int arr[10]; + + int a1[__builtin_classify_type(f()) == void_type_class ? 1 : -1]; + int a2[__builtin_classify_type(i) == integer_type_class ? 1 : -1]; + int a3[__builtin_classify_type(c) == integer_type_class ? 1 : -1]; + int a4[__builtin_classify_type(enum_obj) == enumeral_type_class ? 1 : -1]; + int a5[__builtin_classify_type(b) == boolean_type_class ? 1 : -1]; + int a6[__builtin_classify_type(p) == pointer_type_class ? 1 : -1]; + int a7[__builtin_classify_type(r) == integer_type_class ? 1 : -1]; + int a8[__builtin_classify_type(&cl::baz) == offset_type_class ? 1 : -1]; + int a9[__builtin_classify_type(d) == real_type_class ? 1 : -1]; + int a10[__builtin_classify_type(f) == function_type_class ? 1 : -1]; + int a11[__builtin_classify_type(&cl::bar) == method_type_class ? 1 : -1]; + int a12[__builtin_classify_type(cl_obj) == record_type_class ? 1 : -1]; + int a13[__builtin_classify_type(u_obj) == union_type_class ? 1 : -1]; + int a14[__builtin_classify_type(arr) == array_type_class ? 1 : -1]; + int a15[__builtin_classify_type("abc") == array_type_class ? 1 : -1]; +} + Index: test/Sema/builtin-classify-type.c =================================================================== --- test/Sema/builtin-classify-type.c +++ test/Sema/builtin-classify-type.c @@ -0,0 +1,42 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s + +// expected-no-diagnostics + +enum gcc_type_class { + no_type_class = -1, + void_type_class, integer_type_class, char_type_class, + enumeral_type_class, boolean_type_class, + pointer_type_class, reference_type_class, offset_type_class, + real_type_class, complex_type_class, + function_type_class, method_type_class, + record_type_class, union_type_class, + array_type_class, string_type_class, + lang_type_class +}; + +void foo() { + int i; + char c; + enum { red, green, blue } enum_obj; + int *p; + double d; + _Complex double cc; + extern void f(); + struct { int a; float b; } s_obj; + union { int a; float b; } u_obj; + int arr[10]; + + int a1[__builtin_classify_type(f()) == void_type_class ? 1 : -1]; + int a2[__builtin_classify_type(i) == integer_type_class ? 1 : -1]; + int a3[__builtin_classify_type(c) == integer_type_class ? 1 : -1]; + int a4[__builtin_classify_type(enum_obj) == integer_type_class ? 1 : -1]; + int a5[__builtin_classify_type(p) == pointer_type_class ? 1 : -1]; + int a6[__builtin_classify_type(d) == real_type_class ? 1 : -1]; + int a7[__builtin_classify_type(cc) == complex_type_class ? 1 : -1]; + int a8[__builtin_classify_type(f) == pointer_type_class ? 1 : -1]; + int a0[__builtin_classify_type(s_obj) == record_type_class ? 1 : -1]; + int a10[__builtin_classify_type(u_obj) == union_type_class ? 1 : -1]; + int a11[__builtin_classify_type(arr) == pointer_type_class ? 1 : -1]; + int a12[__builtin_classify_type("abc") == pointer_type_class ? 1 : -1]; +} +
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits