mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-19 11:35:51 -04:00
ba545c814b
Summary: `alloc_align` attribute takes parameter number, not the alignment itself, so given **just** the attribute/function declaration we can't do any sanity checking for said alignment. However, at call site, given the actual `Expr` that is passed into that parameter, we //might// be able to evaluate said `Expr` as Integer Constant Expression, and perform the sanity checks. But since there is no requirement for that argument to be an immediate, we may fail, and that's okay. However if we did evaluate, we should enforce the same constraints as with `__builtin_assume_aligned()`/`__attribute__((assume_aligned(imm)))`: said alignment is a power of two, and is not greater than our magic threshold This was initially committed inc2a9061ac5but reverted in00756b1823because of suspicious bot failures. Reviewers: erichkeane, aaron.ballman, hfinkel, rsmith, jdoerfert Reviewed By: erichkeane Subscribers: cfe-commits Tags: #clang Differential Revision: https://reviews.llvm.org/D72996
47 lines
2.2 KiB
C++
47 lines
2.2 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify %s
|
|
|
|
struct param_num {
|
|
void* Foo(int a) __attribute__((alloc_align(1))); // expected-error {{'alloc_align' attribute is invalid for the implicit this argument}}
|
|
};
|
|
|
|
|
|
template <typename T>
|
|
struct dependent_ret {
|
|
T* Foo(int a) __attribute__((alloc_align(2)));// no-warning, ends up being int**.
|
|
T Foo2(int a) __attribute__((alloc_align(2)));// expected-warning {{'alloc_align' attribute only applies to return values that are pointers or references}}
|
|
};
|
|
|
|
// Following 2 errors associated only with the 'float' versions below.
|
|
template <typename T>
|
|
struct dependent_param_struct {
|
|
void* Foo(T param) __attribute__((alloc_align(2))); // expected-error {{'alloc_align' attribute argument may only refer to a function parameter of integer type}}
|
|
};
|
|
|
|
template <typename T>
|
|
void* dependent_param_func(T param) __attribute__((alloc_align(1)));// expected-error {{'alloc_align' attribute argument may only refer to a function parameter of integer type}}
|
|
|
|
template <int T>
|
|
void* illegal_align_param(int p) __attribute__((alloc_align(T))); // expected-error {{'alloc_align' attribute requires parameter 1 to be an integer constant}}
|
|
|
|
void dependent_impl(int align) {
|
|
dependent_ret<int> a; // expected-note {{in instantiation of template class 'dependent_ret<int>' requested here}}
|
|
a.Foo(1);
|
|
a.Foo2(1);
|
|
dependent_ret<int *> b;
|
|
b.Foo(1);
|
|
b.Foo2(1);
|
|
b.Foo(3); // expected-error {{requested alignment is not a power of 2}}
|
|
b.Foo2(3); // expected-error {{requested alignment is not a power of 2}}
|
|
b.Foo(1073741824); // expected-warning {{requested alignment must be 536870912 bytes or smaller; maximum alignment assumed}}
|
|
b.Foo2(1073741824); // expected-warning {{requested alignment must be 536870912 bytes or smaller; maximum alignment assumed}}
|
|
b.Foo(align);
|
|
b.Foo2(align);
|
|
|
|
dependent_param_struct<int> c;
|
|
c.Foo(1);
|
|
dependent_param_struct<float> d; // expected-note {{in instantiation of template class 'dependent_param_struct<float>' requested here}}
|
|
d.Foo(1.0);
|
|
dependent_param_func<int>(1);
|
|
dependent_param_func<float>(1); // expected-note {{in instantiation of function template specialization 'dependent_param_func<float>' requested here}}
|
|
}
|