[clang] Check ValueDependent instead of InstantiationDependent before executing the align expr for builtin align functions.

[hokein]

Summary

in general, value dependent is a subset of instnatiation dependent. This
would allows us to produce diagnostics for the align expression (which
is instantiation dependent but not value dependent).

[arichardson]

clang/test/SemaCXX/builtin-align-cxx.cpp

40

Could also change this to template <typename T, long A = 31> and add another __builtin_align_up(array, A) but I'm not sure whether that increases test coverage.

[hokein]

add more test.

clang/lib/Sema/SemaChecking.cpp

static bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {
   clang::Expr *AlignOp = TheCall->getArg(1);
   if (!IsValidIntegerType(AlignOp->getType())) {
     S.Diag(AlignOp->getExprLoc(), diag::err_typecheck_expect_int)
         << AlignOp->getType();
     return true;
   }
   Expr::EvalResult AlignResult;
   unsigned MaxAlignmentBits = S.Context.getIntWidth(SrcTy) - 1;
-  // We can't check validity of alignment if it is type dependent.
-  if (!AlignOp->isInstantiationDependent() &&
+  // We can't check validity of alignment if it is value dependent.
+  if (!AlignOp->isValueDependent() &&
       AlignOp->EvaluateAsInt(AlignResult, S.Context,
                              Expr::SE_AllowSideEffects)) {
     llvm::APSInt AlignValue = AlignResult.Val.getInt();
     llvm::APSInt MaxValue(
         llvm::APInt::getOneBitSet(MaxAlignmentBits + 1, MaxAlignmentBits));
     if (AlignValue < 1) {
       S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_small) << 1;
       return true;

clang/test/SemaCXX/builtin-align-cxx.cpp

 // C++-specific checks for the alignment builtins
 // RUN: %clang_cc1 -triple=x86_64-unknown-unknown -std=c++11 -o - %s -fsyntax-only -verify
 
 // Check that we don't crash when using dependent types in __builtin_align:
 template <typename a, a b>
 void *c(void *d) { // expected-note{{candidate template ignored}}
   return __builtin_align_down(d, b);
 }
 
void test() {
   test_templated_arguments<int, 32>(); // fine
   test_templated_arguments<struct fwddecl, 16>();
   // expected-note@-1{{in instantiation of function template specialization 'test_templated_arguments<fwddecl, 16, 16>'}}
   // expected-note@-2{{forward declaration of 'fwddecl'}}
   test_templated_arguments<int, 7>(); // invalid alignment value
   // expected-note@-1{{in instantiation of function template specialization 'test_templated_arguments<int, 7, 16>'}}
 }
 
 template <typename T>
 void test_incorrect_alignment_without_instatiation(T value) {
   int array[32];
   static_assert(__is_same(decltype(__builtin_align_up(array, 31)), int *), // expected-error{{requested alignment is not a power of 2}}
                 "return type should be the decayed array type");
   static_assert(__is_same(decltype(__builtin_align_down(array, 7)), int *), // expected-error{{requested alignment is not a power of 2}}
                 "return type should be the decayed array type");
   static_assert(__is_same(decltype(__builtin_is_aligned(array, -1)), bool), // expected-error{{requested alignment must be 1 or greater}}
                 "return type should be bool");
   __builtin_align_up(array);       // expected-error{{too few arguments to function call, expected 2, have 1}}
   __builtin_align_up(array, 31);   // expected-error{{requested alignment is not a power of 2}}
   __builtin_align_down(array, 31); // expected-error{{requested alignment is not a power of 2}}
   __builtin_align_up(array, 31);   // expected-error{{requested alignment is not a power of 2}}
   __builtin_align_up(value, 31);   // This shouldn't want since the type is dependent
   __builtin_align_up(value);       // Same here
+
+  __builtin_align_up(array, sizeof(sizeof(value)) - 1); // expected-error{{requested alignment is not a power of 2}}
+  __builtin_align_up(array, value); // no diagnostic as the alignment is value dependent.
 }
 
 // The original fix for the issue above broke some legitimate code.
 // Here is a regression test:
 typedef __SIZE_TYPE__ size_t;
 void *allocate_impl(size_t size);
 template <typename T>
 T *allocate() {