Clang Project

clang_source_code/test/SemaCXX/attr-mode-tmpl.cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s
2
3typedef enum { XX } EnumType;
4struct S { int x; };
5
6// Check enumerations. Vector modes on enum types must cause an error.
7template <class T>
8void CheckEnumerations() {
9  // Check that non-vector 'mode' attribute is OK with enumeration types.
10  typedef T __attribute__((mode(QI))) T1;
11  typedef T T2 __attribute__((mode(HI)));
12  typedef T __attribute__((mode(V8SI))) T3; // expected-error{{mode 'V8SI' is not supported for enumeration types}}
13  // expected-warning@-1{{specifying vector types with the 'mode' attribute is deprecated}}
14
15  typedef enum __attribute__((mode(HI))) { A4, B4 } T4;
16  typedef enum { A5, B5 } __attribute__((mode(SI))) T5;
17  typedef enum __attribute__((mode(V2SI))) { A6, B6 } T6; // expected-error{{mode 'V2SI' is not supported for enumeration types}}
18                                                          // expected-warning@-1{{deprecated}}
19  typedef enum { A7, B7 } __attribute__((mode(V2QI))) T7; // expected-error{{mode 'V2QI' is not supported for enumeration types}}
20                                                          // expected-warning@-1{{deprecated}}
21}
22
23// Check that attribute applies only for integer and floating-point types.
24// OK when instantiated with 'int', error with structure types, for example.
25template <class T>
26void CheckPrimitiveTypes() {
27  typedef T __attribute__((mode(QI))) T1;    // expected-error{{mode attribute only supported for integer and floating-point types}}
28  typedef T __attribute__((mode(V2SI))) VT1; // expected-error{{mode attribute only supported for integer and floating-point types}}
29  // expected-warning@-1{{specifying vector types with the 'mode' attribute is deprecated}}
30}
31
32// Check that attribute supports certain modes. Check that wrong machine modes
33// are NOT diagnosed twice during instantiation.
34template <class T>
35void CheckMachineMode() {
36  typedef T __attribute__((mode(QI))) T1; // expected-error{{type of machine mode does not match type of base type}}
37  typedef T __attribute__((mode(HI))) T2; // expected-error{{type of machine mode does not match type of base type}}
38  typedef T __attribute__((mode(SI))) T3; // expected-error{{type of machine mode does not match type of base type}}
39  typedef T __attribute__((mode(DI))) T4; // expected-error{{type of machine mode does not match type of base type}}
40  typedef T __attribute__((mode(SF))) T5; // expected-error2{{type of machine mode does not match type of base type}}
41  typedef T __attribute__((mode(DF))) T6; // expected-error2{{type of machine mode does not match type of base type}}
42  typedef T __attribute__((mode(II))) T7; // expected-error{{unknown machine mode}}
43  typedef T __attribute__((mode(12))) T8; // expected-error{{'mode' attribute requires an identifier}}
44}
45
46// Check attributes on function parameters.
47template <class T1, class T2>
48void CheckParameters(T1 __attribute__((mode(SI)))   paramSI,     // expected-note{{ignored: substitution failure}} expected-note-re{{not viable: no known conversion from '{{.*}}' (vector of 4 '{{.*}}' values) to 'EnumType' for 2nd argument}}
49                     T1 __attribute__((mode(V4DI))) paramV4DI,   // expected-warning{{deprecated}}
50                     T2 __attribute__((mode(SF)))   paramSF,
51                     T2 __attribute__((mode(V4DF))) paramV4DF) { // expected-warning{{deprecated}}
52}
53
54
55// Check dependent structure.
56template <class T>
57struct TemplatedStruct {
58  // Check fields.
59  T __attribute__((mode(HI)))     x1;
60  T __attribute__((mode(V4HI)))   x2;         // expected-error{{mode 'V4HI' is not supported for enumeration types}}
61                                              // expected-warning@-1{{deprecated}}
62
63  // Check typedefs.
64  typedef T __attribute__((mode(DI)))   T1;
65  typedef T __attribute__((mode(V8DI))) T2;   // expected-error{{mode 'V8DI' is not supported for enumeration types}}
66                                              // expected-warning@-1{{deprecated}}
67
68  // Check parameters.
69  void f1(T __attribute__((mode(QI))) x) {}
70  void f2(T __attribute__((mode(SF))) x) {}   // expected-error2{{type of machine mode does not match type of base type}}
71  void f3(T __attribute__((mode(V4QI))) x) {} // expected-error{{mode 'V4QI' is not supported for enumeration types}}
72                                              // expected-warning@-1{{deprecated}}
73
74  // Check attribute on methods - it is invalid.
75  __attribute__((mode(QI))) T g1() { return 0; } // expected-error{{'mode' attribute only applies to variables, enums, typedefs, and non-static data members}}
76};
77
78
79
80int main() {
81  CheckEnumerations<int>();
82  CheckEnumerations<EnumType>(); // expected-note{{in instantiation of}}
83
84  CheckPrimitiveTypes<int>();
85  CheckPrimitiveTypes<S>();      // expected-note{{in instantiation of}}
86
87  // 'II' mode is unknown, no matter what we instantiate with.
88  CheckMachineMode<int>();       // expected-note{{in instantiation of}}
89  CheckMachineMode<EnumType>();  // expected-note{{in instantiation of}}
90  CheckMachineMode<float>();     // expected-note{{in instantiation of}}
91
92  int   __attribute__((mode(V4DI))) valV4DI; // expected-warning{{deprecated}}
93  float __attribute__((mode(V4DF))) valV4DF; // expected-warning{{deprecated}}
94  // OK.
95  CheckParameters<int, float>(0, valV4DI, 1.0, valV4DF);
96  // Enumeral type with vector mode is invalid.
97  CheckParameters<EnumType, float>(0, valV4DI, 1.0, valV4DF); // expected-error{{no matching function for call}}
98  // 'V4DF' mode with 'int' type is invalid.
99  CheckParameters<int, int>(0, valV4DI, 1, valV4DF); // expected-error{{no matching function for call}}
100
101  TemplatedStruct<int>      s1; // expected-note{{in instantiation of}}
102  TemplatedStruct<EnumType> s2; // expected-note{{in instantiation of}}
103  return 0;
104}
105
CodeThinker, Enjoy your reading code